Index: kernel/Makefile =================================================================== --- kernel/Makefile (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/Makefile (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -257,4 +257,15 @@ generic/src/ipc/ipc.c \ generic/src/ipc/sysipc.c \ + generic/src/ipc/sysipc_ops.c \ + generic/src/ipc/ops/clnestab.c \ + generic/src/ipc/ops/conctmeto.c \ + generic/src/ipc/ops/concttome.c \ + generic/src/ipc/ops/connclone.c \ + generic/src/ipc/ops/dataread.c \ + generic/src/ipc/ops/datawrite.c \ + generic/src/ipc/ops/debug.c \ + generic/src/ipc/ops/sharein.c \ + generic/src/ipc/ops/shareout.c \ + generic/src/ipc/ops/stchngath.c \ generic/src/ipc/ipcrsc.c \ generic/src/ipc/irq.c \ Index: kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c =================================================================== --- kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -160,6 +160,6 @@ ASSERT(beagleboard.dispc); - /* Initialize timer, pick timer1, because it is in always-power domain - * and has special capabilities for regular ticks */ + /* Initialize timer. Use timer1, because it is in WKUP power domain + * (always on) and has special capabilities for precise 1ms ticks */ amdm37x_gpt_timer_ticks_init(&beagleboard.timer, AMDM37x_GPT1_BASE_ADDRESS, AMDM37x_GPT1_SIZE, HZ); Index: kernel/genarch/include/drivers/arm926_uart/arm926_uart.h =================================================================== --- kernel/genarch/include/drivers/arm926_uart/arm926_uart.h (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/genarch/include/drivers/arm926_uart/arm926_uart.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -35,6 +35,6 @@ */ -#ifndef KERN_S3C24XX_UART_H_ -#define KERN_S3C24XX_UART_H_ +#ifndef KERN_ARM926_UART_H_ +#define KERN_ARM926_UART_H_ #include Index: kernel/genarch/include/multiboot/multiboot.h =================================================================== --- kernel/genarch/include/multiboot/multiboot.h (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/genarch/include/multiboot/multiboot.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -99,4 +99,5 @@ extern void multiboot_extract_command(char *, size_t, const char *); +extern void multiboot_extract_argument(char *, size_t, const char *); extern void multiboot_info_parse(uint32_t, const multiboot_info_t *); Index: kernel/genarch/src/multiboot/multiboot.c =================================================================== --- kernel/genarch/src/multiboot/multiboot.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/genarch/src/multiboot/multiboot.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -71,4 +71,33 @@ } +/** Extract arguments from the multiboot module command line. + * + * @param buf Destination buffer (will be always NULL-terminated). + * @param size Size of destination buffer (in bytes). + * @param cmd_line Input string (the command line). + * + */ +void multiboot_extract_argument(char *buf, size_t size, const char *cmd_line) +{ + /* Start after first space. */ + const char *start = str_chr(cmd_line, ' '); + if (start == NULL) { + str_cpy(buf, size, ""); + return; + } + + const char *end = cmd_line + str_size(cmd_line); + + /* Skip the space(s). */ + while (start != end) { + if (start[0] == ' ') + start++; + else + break; + } + + str_ncpy(buf, size, start, (size_t) (end - start)); +} + static void multiboot_modules(uint32_t count, multiboot_module_t *mods) { @@ -84,6 +113,10 @@ multiboot_extract_command(init.tasks[init.cnt].name, CONFIG_TASK_NAME_BUFLEN, MULTIBOOT_PTR(mods[i].string)); - } else + multiboot_extract_argument(init.tasks[init.cnt].arguments, + CONFIG_TASK_ARGUMENTS_BUFLEN, MULTIBOOT_PTR(mods[i].string)); + } else { init.tasks[init.cnt].name[0] = 0; + init.tasks[init.cnt].arguments[0] = 0; + } init.cnt++; Index: kernel/genarch/src/multiboot/multiboot2.c =================================================================== --- kernel/genarch/src/multiboot/multiboot2.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/genarch/src/multiboot/multiboot2.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -49,4 +49,6 @@ multiboot_extract_command(init.tasks[init.cnt].name, CONFIG_TASK_NAME_BUFLEN, module->string); + multiboot_extract_argument(init.tasks[init.cnt].arguments, + CONFIG_TASK_ARGUMENTS_BUFLEN, module->string); init.cnt++; Index: kernel/generic/include/config.h =================================================================== --- kernel/generic/include/config.h (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/include/config.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -47,4 +47,11 @@ #define CONFIG_INIT_TASKS 32 #define CONFIG_TASK_NAME_BUFLEN 32 +#define CONFIG_TASK_ARGUMENTS_BUFLEN 64 + +/** + * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ + * requests. + */ +#define DATA_XFER_LIMIT (64 * 1024) #ifndef __ASM__ @@ -56,4 +63,5 @@ size_t size; char name[CONFIG_TASK_NAME_BUFLEN]; + char arguments[CONFIG_TASK_ARGUMENTS_BUFLEN]; } init_task_t; Index: kernel/generic/include/ipc/ipc.h =================================================================== --- kernel/generic/include/ipc/ipc.h (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/include/ipc/ipc.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -65,4 +65,5 @@ mutex_t lock; link_t link; + struct task *caller; struct answerbox *callee; ipc_phone_state_t state; @@ -72,4 +73,7 @@ typedef struct answerbox { IRQ_SPINLOCK_DECLARE(lock); + + /** Answerbox is active until it enters cleanup. */ + bool active; struct task *task; @@ -106,10 +110,43 @@ typedef struct { - link_t link; + /** + * Task link. + * Valid only when the call is not forgotten. + * Protected by the task's active_calls_lock. + */ + link_t ta_link; + + atomic_t refcnt; + + /** Answerbox link. */ + link_t ab_link; unsigned int flags; + + /** Protects the forget member. */ + SPINLOCK_DECLARE(forget_lock); + + /** + * True if the caller 'forgot' this call and donated it to the callee. + * Forgotten calls are discarded upon answering (the answer is not + * delivered) and answered calls cannot be forgotten. Forgotten calls + * also do not figure on the task's active call list. + * + * We keep this separate from the flags so that it is not necessary + * to take a lock when accessing them. + */ + bool forget; + + /** True if the call is in the active list. */ + bool active; - /** Identification of the caller. */ + /** + * Identification of the caller. + * Valid only when the call is not forgotten. + */ struct task *sender; + + /** Phone which was used to send the call. */ + phone_t *caller_phone; /** Private data to internal IPC. */ @@ -118,14 +155,10 @@ /** Data passed from/to userspace. */ ipc_data_t data; - + + /** Method as it was sent in the request. */ + sysarg_t request_method; + /** Buffer for IPC_M_DATA_WRITE and IPC_M_DATA_READ. */ uint8_t *buffer; - - /* - * The forward operation can masquerade the caller phone. For those - * cases, we must keep it aside so that the answer is processed - * correctly. - */ - phone_t *caller_phone; } call_t; @@ -136,4 +169,6 @@ extern call_t *ipc_call_alloc(unsigned int); extern void ipc_call_free(call_t *); +extern void ipc_call_hold(call_t *); +extern void ipc_call_release(call_t *); extern int ipc_call(phone_t *, call_t *); @@ -141,7 +176,8 @@ extern int ipc_forward(call_t *, phone_t *, answerbox_t *, unsigned int); extern void ipc_answer(answerbox_t *, call_t *); +extern void _ipc_answer_free_call(call_t *, bool); -extern void ipc_phone_init(phone_t *); -extern void ipc_phone_connect(phone_t *, answerbox_t *); +extern void ipc_phone_init(phone_t *, struct task *); +extern bool ipc_phone_connect(phone_t *, answerbox_t *); extern int ipc_phone_hangup(phone_t *); @@ -151,5 +187,5 @@ extern void ipc_backsend_err(phone_t *, call_t *, sysarg_t); extern void ipc_answerbox_slam_phones(answerbox_t *, bool); -extern void ipc_cleanup_call_list(list_t *); +extern void ipc_cleanup_call_list(answerbox_t *, list_t *); extern void ipc_print_task(task_id_t); Index: kernel/generic/include/ipc/ipcrsc.h =================================================================== --- kernel/generic/include/ipc/ipcrsc.h (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/include/ipc/ipcrsc.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -40,6 +40,7 @@ extern call_t *get_call(sysarg_t); +extern int phone_get(sysarg_t, phone_t **); extern int phone_alloc(task_t *); -extern void phone_connect(int, answerbox_t *); +extern bool phone_connect(int, answerbox_t *); extern void phone_dealloc(int); Index: kernel/generic/include/ipc/sysipc_ops.h =================================================================== --- kernel/generic/include/ipc/sysipc_ops.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/include/ipc/sysipc_ops.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#ifndef KERN_SYSIPC_OPS_H_ +#define KERN_SYSIPC_OPS_H_ + +#include + +#define SYSIPC_OP(op, call, ...) \ + ({ \ + int rc = EOK; \ + \ + sysipc_ops_t *ops; \ + ops = sysipc_ops_get((call)->request_method); \ + if (ops->op) \ + rc = ops->op((call), ##__VA_ARGS__); \ + rc; \ + }) + +/** + * This header declares the per-method IPC callbacks. Using these callbacks, + * each IPC method (but system methods in particular), can define actions that + * will be called at specific moments in the call life-cycle. + * + * Normally, the kernel will attempt to invoke the following callbacks in the + * following order on each call: + * + * request_preprocess() + * request_process() + * answer_preprocess() + * answer_process() + * + * This callback invocation sequence is a natural order of processing. Note, + * however, that due to various special circumstances, callbacks may be called + * also in a different than natural order of processing. This means that some + * callbacks may be skipped and some others may be called instead. + * + * The additional callbacks that may be called are as follows: + * + * request_forget() + * answer_cleanup() + * + * There are several notable scenarios in which some callbacks of the natural + * order of processing will be skipped. + * + * The request_process(), answer_preprocess() and answer_process() callbacks + * will be skipped if the call cannot be delivered to the callee. This may + * happen when e.g. the request_preprocess() callback fails or the connection + * to the callee is not functional. The next callback that will be invoked on + * the call is request_forget(). + * + * The comments for each callback type describe the specifics of each callback + * such as the context in which it is invoked and various constraints. + */ + +typedef struct { + /** + * This callback is called from request_preprocess(). + * + * Context: caller + * Caller alive: guaranteed + * Races with: N/A + * Invoked on: all calls + */ + int (* request_preprocess)(call_t *, phone_t *); + + /** + * This callback is called when the IPC cleanup code wins the race to + * forget the call. + * + * Context: caller + * Caller alive: guaranteed + * Races with: request_process(), answer_cleanup(), + * _ipc_answer_free_call() + * Invoked on: all forgotten calls + */ + int (* request_forget)(call_t *); + + /** + * This callback is called from process_request(). + * + * Context: callee + * Caller alive: no guarantee + * Races with: request_forget() + * Invoked on: all calls delivered to the callee + */ + int (* request_process)(call_t *, answerbox_t *); + + /** + * This callback is called when answer_preprocess() loses the race to + * answer the call. + * + * Context: callee + * Caller alive: no guarantee + * Races with: request_forget() + * Invoked on: all forgotten calls + */ + int (* answer_cleanup)(call_t *, ipc_data_t *); + + /** + * This callback is called when answer_preprocess() wins the race to + * answer the call. + * + * Context: callee + * Caller alive: guaranteed + * Races with: N/A + * Invoked on: all answered calls + */ + int (* answer_preprocess)(call_t *, ipc_data_t *); + + /** + * This callback is called from process_answer(). + * + * Context: caller + * Caller alive: guaranteed + * Races with: N/A + * Invoked on: all answered calls + */ + int (* answer_process)(call_t *); +} sysipc_ops_t; + +extern sysipc_ops_t *sysipc_ops_get(sysarg_t); + +extern int null_request_preprocess(call_t *, phone_t *); +extern int null_request_forget(call_t *); +extern int null_request_process(call_t *, answerbox_t *); +extern int null_answer_cleanup(call_t *, ipc_data_t *); +extern int null_answer_preprocess(call_t *, ipc_data_t *); +extern int null_answer_process(call_t *); + +#endif + +/** @} + */ Index: kernel/generic/include/ipc/sysipc_priv.h =================================================================== --- kernel/generic/include/ipc/sysipc_priv.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/include/ipc/sysipc_priv.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#ifndef KERN_SYSIPC_PRIV_H_ +#define KERN_SYSIPC_PRIV_H_ + +#include + +extern int answer_preprocess(call_t *, ipc_data_t *); + +#endif + +/** @} + */ Index: kernel/generic/include/proc/task.h =================================================================== --- kernel/generic/include/proc/task.h (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/include/proc/task.h (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -91,8 +91,24 @@ /* IPC stuff */ - answerbox_t answerbox; /**< Communication endpoint */ + + /** Receiving communication endpoint */ + answerbox_t answerbox; + + /** Sending communication endpoints */ phone_t phones[IPC_MAX_PHONES]; - stats_ipc_t ipc_info; /**< IPC statistics */ + + /** Spinlock protecting the active_calls list. */ + SPINLOCK_DECLARE(active_calls_lock); + + /** + * List of all calls sent by this task that have not yet been + * answered. + */ + list_t active_calls; + event_t events[EVENT_TASK_END - EVENT_END]; + + /** IPC statistics */ + stats_ipc_t ipc_info; #ifdef CONFIG_UDEBUG Index: kernel/generic/src/ipc/event.c =================================================================== --- kernel/generic/src/ipc/event.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/ipc/event.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -163,9 +163,13 @@ call->data.task_id = TASK ? TASK->taskid : 0; - irq_spinlock_lock(&event->answerbox->irq_lock, true); - list_append(&call->link, &event->answerbox->irq_notifs); - irq_spinlock_unlock(&event->answerbox->irq_lock, true); - - waitq_wakeup(&event->answerbox->wq, WAKEUP_FIRST); + irq_spinlock_lock(&event->answerbox->irq_lock, + true); + list_append(&call->ab_link, + &event->answerbox->irq_notifs); + irq_spinlock_unlock(&event->answerbox->irq_lock, + true); + + waitq_wakeup(&event->answerbox->wq, + WAKEUP_FIRST); if (mask) Index: kernel/generic/src/ipc/ipc.c =================================================================== --- kernel/generic/src/ipc/ipc.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/ipc/ipc.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -45,4 +45,6 @@ #include #include +#include +#include #include #include @@ -71,6 +73,23 @@ { memsetb(call, sizeof(*call), 0); - call->sender = TASK; + spinlock_initialize(&call->forget_lock, "forget_lock"); + call->active = false; + call->forget = false; + call->sender = NULL; call->buffer = NULL; +} + +void ipc_call_hold(call_t *call) +{ + atomic_inc(&call->refcnt); +} + +void ipc_call_release(call_t *call) +{ + if (atomic_predec(&call->refcnt) == 0) { + if (call->buffer) + free(call->buffer); + slab_free(ipc_call_slab, call); + } } @@ -83,5 +102,5 @@ * * @return If flags permit it, return NULL, or initialized kernel - * call structure. + * call structure with one reference. * */ @@ -89,6 +108,8 @@ { call_t *call = slab_alloc(ipc_call_slab, flags); - if (call) + if (call) { _ipc_call_init(call); + ipc_call_hold(call); + } return call; @@ -102,8 +123,5 @@ void ipc_call_free(call_t *call) { - /* Check to see if we have data in the IPC_M_DATA_SEND buffer. */ - if (call->buffer) - free(call->buffer); - slab_free(ipc_call_slab, call); + ipc_call_release(call); } @@ -132,18 +150,24 @@ * @param phone Initialized phone structure. * @param box Initialized answerbox structure. - * - */ -void ipc_phone_connect(phone_t *phone, answerbox_t *box) -{ + * @return True if the phone was connected, false otherwise. + */ +bool ipc_phone_connect(phone_t *phone, answerbox_t *box) +{ + bool active; + mutex_lock(&phone->lock); - - phone->state = IPC_PHONE_CONNECTED; - phone->callee = box; - irq_spinlock_lock(&box->lock, true); - list_append(&phone->link, &box->connected_phones); + + active = box->active; + if (active) { + phone->state = IPC_PHONE_CONNECTED; + phone->callee = box; + list_append(&phone->link, &box->connected_phones); + } + irq_spinlock_unlock(&box->lock, true); - mutex_unlock(&phone->lock); + + return active; } @@ -151,9 +175,11 @@ * * @param phone Phone structure to be initialized. - * - */ -void ipc_phone_init(phone_t *phone) + * @param caller Owning task. + * + */ +void ipc_phone_init(phone_t *phone, task_t *caller) { mutex_initialize(&phone->lock, MUTEX_PASSIVE); + phone->caller = caller; phone->callee = NULL; phone->state = IPC_PHONE_FREE; @@ -167,23 +193,36 @@ * */ -static void _ipc_answer_free_call(call_t *call, bool selflocked) -{ - answerbox_t *callerbox = &call->sender->answerbox; - bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox)); - +void _ipc_answer_free_call(call_t *call, bool selflocked) +{ /* Count sent answer */ irq_spinlock_lock(&TASK->lock, true); TASK->ipc_info.answer_sent++; irq_spinlock_unlock(&TASK->lock, true); + + spinlock_lock(&call->forget_lock); + if (call->forget) { + /* This is a forgotten call and call->sender is not valid. */ + spinlock_unlock(&call->forget_lock); + ipc_call_free(call); + return; + } else { + /* + * If the call is still active, i.e. it was answered + * in a non-standard way, remove the call from the + * sender's active call list. + */ + if (call->active) { + spinlock_lock(&call->sender->active_calls_lock); + list_remove(&call->ta_link); + spinlock_unlock(&call->sender->active_calls_lock); + } + } + spinlock_unlock(&call->forget_lock); + + answerbox_t *callerbox = &call->sender->answerbox; + bool do_lock = ((!selflocked) || (callerbox != &TASK->answerbox)); call->flags |= IPC_CALL_ANSWERED; - if (call->flags & IPC_CALL_FORWARDED) { - if (call->caller_phone) { - /* Demasquerade the caller phone. */ - call->data.phone = call->caller_phone; - } - } - call->data.task_id = TASK->taskid; @@ -191,5 +230,5 @@ irq_spinlock_lock(&callerbox->lock, true); - list_append(&call->link, &callerbox->answers); + list_append(&call->ab_link, &callerbox->answers); if (do_lock) @@ -209,9 +248,26 @@ /* Remove from active box */ irq_spinlock_lock(&box->lock, true); - list_remove(&call->link); + list_remove(&call->ab_link); irq_spinlock_unlock(&box->lock, true); /* Send back answer */ _ipc_answer_free_call(call, false); +} + +static void _ipc_call_actions_internal(phone_t *phone, call_t *call) +{ + task_t *caller = phone->caller; + + atomic_inc(&phone->active_calls); + call->caller_phone = phone; + call->sender = caller; + + call->active = true; + spinlock_lock(&caller->active_calls_lock); + list_append(&call->ta_link, &caller->active_calls); + spinlock_unlock(&caller->active_calls_lock); + + call->data.phone = phone; + call->data.task_id = caller->taskid; } @@ -228,6 +284,5 @@ void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err) { - call->data.phone = phone; - atomic_inc(&phone->active_calls); + _ipc_call_actions_internal(phone, call); IPC_SET_RETVAL(call->data, err); _ipc_answer_free_call(call, false); @@ -243,17 +298,16 @@ static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call) { + task_t *caller = phone->caller; + /* Count sent ipc call */ - irq_spinlock_lock(&TASK->lock, true); - TASK->ipc_info.call_sent++; - irq_spinlock_unlock(&TASK->lock, true); - - if (!(call->flags & IPC_CALL_FORWARDED)) { - atomic_inc(&phone->active_calls); - call->data.phone = phone; - call->data.task_id = TASK->taskid; - } + irq_spinlock_lock(&caller->lock, true); + caller->ipc_info.call_sent++; + irq_spinlock_unlock(&caller->lock, true); + + if (!(call->flags & IPC_CALL_FORWARDED)) + _ipc_call_actions_internal(phone, call); irq_spinlock_lock(&box->lock, true); - list_append(&call->link, &box->calls); + list_append(&call->ab_link, &box->calls); irq_spinlock_unlock(&box->lock, true); @@ -275,8 +329,5 @@ if (phone->state != IPC_PHONE_CONNECTED) { mutex_unlock(&phone->lock); - if (call->flags & IPC_CALL_FORWARDED) { - IPC_SET_RETVAL(call->data, EFORWARD); - _ipc_answer_free_call(call, false); - } else { + if (!(call->flags & IPC_CALL_FORWARDED)) { if (phone->state == IPC_PHONE_HUNGUP) ipc_backsend_err(phone, call, EHANGUP); @@ -325,4 +376,5 @@ call_t *call = ipc_call_alloc(0); IPC_SET_IMETHOD(call->data, IPC_M_PHONE_HUNGUP); + call->request_method = IPC_M_PHONE_HUNGUP; call->flags |= IPC_CALL_DISCARD_ANSWER; _ipc_call(phone, box, call); @@ -356,10 +408,8 @@ TASK->ipc_info.forwarded++; irq_spinlock_pass(&TASK->lock, &oldbox->lock); - list_remove(&call->link); + list_remove(&call->ab_link); irq_spinlock_unlock(&oldbox->lock, true); if (mode & IPC_FF_ROUTE_FROM_ME) { - if (!call->caller_phone) - call->caller_phone = call->data.phone; call->data.phone = newphone; call->data.task_id = TASK->taskid; @@ -406,6 +456,6 @@ request = list_get_instance(list_first(&box->irq_notifs), - call_t, link); - list_remove(&request->link); + call_t, ab_link); + list_remove(&request->ab_link); irq_spinlock_unlock(&box->irq_lock, false); @@ -416,7 +466,7 @@ /* Handle asynchronous answers */ request = list_get_instance(list_first(&box->answers), - call_t, link); - list_remove(&request->link); - atomic_dec(&request->data.phone->active_calls); + call_t, ab_link); + list_remove(&request->ab_link); + atomic_dec(&request->caller_phone->active_calls); } else if (!list_empty(&box->calls)) { /* Count received call */ @@ -425,9 +475,9 @@ /* Handle requests */ request = list_get_instance(list_first(&box->calls), - call_t, link); - list_remove(&request->link); + call_t, ab_link); + list_remove(&request->ab_link); /* Append request to dispatch queue */ - list_append(&request->link, &box->dispatched_calls); + list_append(&request->ab_link, &box->dispatched_calls); } else { /* This can happen regularly after ipc_cleanup */ @@ -449,19 +499,29 @@ /** Answer all calls from list with EHANGUP answer. * + * @param box Answerbox with the list. * @param lst Head of the list to be cleaned up. - * - */ -void ipc_cleanup_call_list(list_t *lst) -{ + */ +void ipc_cleanup_call_list(answerbox_t *box, list_t *lst) +{ + irq_spinlock_lock(&box->lock, true); while (!list_empty(lst)) { - call_t *call = list_get_instance(list_first(lst), call_t, link); - if (call->buffer) - free(call->buffer); - - list_remove(&call->link); - + call_t *call = list_get_instance(list_first(lst), call_t, + ab_link); + + list_remove(&call->ab_link); + + irq_spinlock_unlock(&box->lock, true); + + if (lst == &box->calls) + SYSIPC_OP(request_process, call, box); + + ipc_data_t old = call->data; IPC_SET_RETVAL(call->data, EHANGUP); + answer_preprocess(call, &old); _ipc_answer_free_call(call, true); - } + + irq_spinlock_lock(&box->lock, true); + } + irq_spinlock_unlock(&box->lock, true); } @@ -501,5 +561,7 @@ mutex_unlock(&phone->lock); irq_spinlock_unlock(&box->lock, true); - + + // FIXME: phone can become deallocated at any time now + /* * Send one message to the answerbox for each @@ -509,4 +571,5 @@ */ IPC_SET_IMETHOD(call->data, IPC_M_PHONE_HUNGUP); + call->request_method = IPC_M_PHONE_HUNGUP; call->flags |= IPC_CALL_DISCARD_ANSWER; _ipc_call(phone, box, call); @@ -529,4 +592,127 @@ } +static void ipc_forget_all_active_calls(void) +{ + call_t *call; + +restart: + spinlock_lock(&TASK->active_calls_lock); + if (list_empty(&TASK->active_calls)) { + /* + * We are done, there are no more active calls. + * Nota bene: there may still be answers waiting for pick up. + */ + spinlock_unlock(&TASK->active_calls_lock); + return; + } + + call = list_get_instance(list_first(&TASK->active_calls), call_t, + ta_link); + + if (!spinlock_trylock(&call->forget_lock)) { + /* + * Avoid deadlock and let async_answer() or + * _ipc_answer_free_call() win the race to dequeue the first + * call on the list. + */ + spinlock_unlock(&TASK->active_calls_lock); + goto restart; + } + + /* + * Forget the call and donate it to the task which holds up the answer. + */ + + call->forget = true; + call->sender = NULL; + list_remove(&call->ta_link); + + /* + * The call may be freed by _ipc_answer_free_call() before we are done + * with it; to avoid working with a destroyed call_t structure, we + * must hold a reference to it. + */ + ipc_call_hold(call); + + spinlock_unlock(&call->forget_lock); + spinlock_unlock(&TASK->active_calls_lock); + + atomic_dec(&call->caller_phone->active_calls); + + SYSIPC_OP(request_forget, call); + + ipc_call_release(call); + + goto restart; +} + +/** Wait for all answers to asynchronous calls to arrive. */ +static void ipc_wait_for_all_answered_calls(void) +{ + call_t *call; + size_t i; + +restart: + /* + * Go through all phones, until they are all free. + * Locking is needed as there may be connection handshakes in progress. + */ + for (i = 0; i < IPC_MAX_PHONES; i++) { + phone_t *phone = &TASK->phones[i]; + + mutex_lock(&phone->lock); + if ((phone->state == IPC_PHONE_HUNGUP) && + (atomic_get(&phone->active_calls) == 0)) { + phone->state = IPC_PHONE_FREE; + phone->callee = NULL; + } + + /* + * We might have had some IPC_PHONE_CONNECTING phones at the + * beginning of ipc_cleanup(). Depending on whether these were + * forgotten or answered, they will eventually enter the + * IPC_PHONE_FREE or IPC_PHONE_CONNECTED states, respectively. + * In the latter case, the other side may slam the open phones + * at any time, in which case we will get an IPC_PHONE_SLAMMED + * phone. + */ + if ((phone->state == IPC_PHONE_CONNECTED) || + (phone->state == IPC_PHONE_SLAMMED)) { + mutex_unlock(&phone->lock); + ipc_phone_hangup(phone); + /* + * Now there may be one extra active call, which needs + * to be forgotten. + */ + ipc_forget_all_active_calls(); + goto restart; + } + + /* + * If the hangup succeeded, it has sent a HANGUP message, the + * IPC is now in HUNGUP state, we wait for the reply to come + */ + if (phone->state != IPC_PHONE_FREE) { + mutex_unlock(&phone->lock); + break; + } + + mutex_unlock(&phone->lock); + } + + /* Got into cleanup */ + if (i == IPC_MAX_PHONES) + return; + + call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT, + SYNCH_FLAGS_NONE); + ASSERT(call->flags & (IPC_CALL_ANSWERED | IPC_CALL_NOTIF)); + + SYSIPC_OP(answer_process, call); + + ipc_call_free(call); + goto restart; +} + /** Clean up all IPC communication of the current task. * @@ -537,7 +723,16 @@ void ipc_cleanup(void) { + /* + * Mark the answerbox as inactive. + * + * The main purpose for doing this is to prevent any pending callback + * connections from getting established beyond this point. + */ + irq_spinlock_lock(&TASK->answerbox.lock, true); + TASK->answerbox.active = false; + irq_spinlock_unlock(&TASK->answerbox.lock, true); + /* Disconnect all our phones ('ipc_phone_hangup') */ - size_t i; - for (i = 0; i < IPC_MAX_PHONES; i++) + for (size_t i = 0; i < IPC_MAX_PHONES; i++) ipc_phone_hangup(&TASK->phones[i]); @@ -557,51 +752,10 @@ /* Answer all messages in 'calls' and 'dispatched_calls' queues */ - irq_spinlock_lock(&TASK->answerbox.lock, true); - ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls); - ipc_cleanup_call_list(&TASK->answerbox.calls); - irq_spinlock_unlock(&TASK->answerbox.lock, true); - - /* Wait for all answers to asynchronous calls to arrive */ - while (true) { - /* - * Go through all phones, until they are all FREE - * Locking is not needed, no one else should modify - * it when we are in cleanup - */ - for (i = 0; i < IPC_MAX_PHONES; i++) { - if (TASK->phones[i].state == IPC_PHONE_HUNGUP && - atomic_get(&TASK->phones[i].active_calls) == 0) { - TASK->phones[i].state = IPC_PHONE_FREE; - TASK->phones[i].callee = NULL; - } - - /* - * Just for sure, we might have had some - * IPC_PHONE_CONNECTING phones - */ - if (TASK->phones[i].state == IPC_PHONE_CONNECTED) - ipc_phone_hangup(&TASK->phones[i]); - - /* - * If the hangup succeeded, it has sent a HANGUP - * message, the IPC is now in HUNGUP state, we - * wait for the reply to come - */ - - if (TASK->phones[i].state != IPC_PHONE_FREE) - break; - } - - /* Got into cleanup */ - if (i == IPC_MAX_PHONES) - break; - - call_t *call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT, - SYNCH_FLAGS_NONE); - ASSERT((call->flags & IPC_CALL_ANSWERED) || - (call->flags & IPC_CALL_NOTIF)); - - ipc_call_free(call); - } + ipc_cleanup_call_list(&TASK->answerbox, &TASK->answerbox.calls); + ipc_cleanup_call_list(&TASK->answerbox, + &TASK->answerbox.dispatched_calls); + + ipc_forget_all_active_calls(); + ipc_wait_for_all_answered_calls(); } @@ -615,4 +769,38 @@ ipc_answerbox_slab = slab_cache_create("answerbox_t", sizeof(answerbox_t), 0, NULL, NULL, 0); +} + + +static void ipc_print_call_list(list_t *list) +{ + list_foreach(*list, cur) { + call_t *call = list_get_instance(cur, call_t, ab_link); + +#ifdef __32_BITS__ + printf("%10p ", call); +#endif + +#ifdef __64_BITS__ + printf("%18p ", call); +#endif + + spinlock_lock(&call->forget_lock); + + printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun + " %-6" PRIun " %-6" PRIun " %-7x", + IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), + IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), + IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), + call->flags); + + if (call->forget) { + printf(" ? (call forgotten)\n"); + } else { + printf(" %" PRIu64 " (%s)\n", + call->sender->taskid, call->sender->name); + } + + spinlock_unlock(&call->forget_lock); + } } @@ -688,62 +876,9 @@ printf(" --- incomming calls ---\n"); - list_foreach(task->answerbox.calls, cur) { - call_t *call = list_get_instance(cur, call_t, link); - -#ifdef __32_BITS__ - printf("%10p ", call); -#endif - -#ifdef __64_BITS__ - printf("%18p ", call); -#endif - - printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun - " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n", - IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), - IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), - IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), - call->flags, call->sender->taskid, call->sender->name); - } - + ipc_print_call_list(&task->answerbox.calls); printf(" --- dispatched calls ---\n"); - list_foreach(task->answerbox.dispatched_calls, cur) { - call_t *call = list_get_instance(cur, call_t, link); - -#ifdef __32_BITS__ - printf("%10p ", call); -#endif - -#ifdef __64_BITS__ - printf("%18p ", call); -#endif - - printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun - " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n", - IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), - IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), - IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), - call->flags, call->sender->taskid, call->sender->name); - } - + ipc_print_call_list(&task->answerbox.dispatched_calls); printf(" --- incoming answers ---\n"); - list_foreach(task->answerbox.answers, cur) { - call_t *call = list_get_instance(cur, call_t, link); - -#ifdef __32_BITS__ - printf("%10p ", call); -#endif - -#ifdef __64_BITS__ - printf("%18p ", call); -#endif - - printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun - " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n", - IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), - IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), - IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), - call->flags, call->sender->taskid, call->sender->name); - } + ipc_print_call_list(&task->answerbox.answers); irq_spinlock_unlock(&task->answerbox.lock, false); Index: kernel/generic/src/ipc/ipcrsc.c =================================================================== --- kernel/generic/src/ipc/ipcrsc.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/ipc/ipcrsc.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -132,4 +132,5 @@ #include #include +#include /** Find call_t * in call table according to callid. @@ -151,5 +152,5 @@ list_foreach(TASK->answerbox.dispatched_calls, lst) { - call_t *call = list_get_instance(lst, call_t, link); + call_t *call = list_get_instance(lst, call_t, ab_link); if ((sysarg_t) call == callid) { result = call; @@ -162,4 +163,21 @@ } +/** Get phone from the current task by ID. + * + * @param phoneid Phone ID. + * @param phone Place to store pointer to phone. + * + * @return EOK on success, EINVAL if ID is invalid. + * + */ +int phone_get(sysarg_t phoneid, phone_t **phone) +{ + if (phoneid >= IPC_MAX_PHONES) + return EINVAL; + + *phone = &TASK->phones[phoneid]; + return EOK; +} + /** Allocate new phone slot in the specified task. * @@ -176,10 +194,12 @@ size_t i; for (i = 0; i < IPC_MAX_PHONES; i++) { - if ((task->phones[i].state == IPC_PHONE_HUNGUP) && - (atomic_get(&task->phones[i].active_calls) == 0)) - task->phones[i].state = IPC_PHONE_FREE; + phone_t *phone = &task->phones[i]; + + if ((phone->state == IPC_PHONE_HUNGUP) && + (atomic_get(&phone->active_calls) == 0)) + phone->state = IPC_PHONE_FREE; - if (task->phones[i].state == IPC_PHONE_FREE) { - task->phones[i].state = IPC_PHONE_CONNECTING; + if (phone->state == IPC_PHONE_FREE) { + phone->state = IPC_PHONE_CONNECTING; break; } @@ -223,4 +243,5 @@ * @param phoneid Phone handle to be connected. * @param box Answerbox to which to connect the phone handle. + * @return True if the phone was connected, false otherwise. * * The procedure _enforces_ that the user first marks the phone @@ -229,10 +250,10 @@ * */ -void phone_connect(int phoneid, answerbox_t *box) +bool phone_connect(int phoneid, answerbox_t *box) { phone_t *phone = &TASK->phones[phoneid]; ASSERT(phone->state == IPC_PHONE_CONNECTING); - ipc_phone_connect(phone, box); + return ipc_phone_connect(phone, box); } Index: kernel/generic/src/ipc/irq.c =================================================================== --- kernel/generic/src/ipc/irq.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/ipc/irq.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -510,5 +510,5 @@ { irq_spinlock_lock(&irq->notif_cfg.answerbox->irq_lock, false); - list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs); + list_append(&call->ab_link, &irq->notif_cfg.answerbox->irq_notifs); irq_spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock, false); Index: kernel/generic/src/ipc/kbox.c =================================================================== --- kernel/generic/src/ipc/kbox.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/ipc/kbox.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -48,4 +48,12 @@ { /* + * Not really needed, just to be consistent with the meaning of + * answerbox_t.active. + */ + irq_spinlock_lock(&TASK->kb.box.lock, true); + TASK->kb.box.active = false; + irq_spinlock_unlock(&TASK->kb.box.lock, true); + + /* * Only hold kb.cleanup_lock while setting kb.finished - * this is enough. @@ -88,8 +96,6 @@ /* Answer all messages in 'calls' and 'dispatched_calls' queues. */ - irq_spinlock_lock(&TASK->kb.box.lock, true); - ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls); - ipc_cleanup_call_list(&TASK->kb.box.calls); - irq_spinlock_unlock(&TASK->kb.box.lock, true); + ipc_cleanup_call_list(&TASK->kb.box, &TASK->kb.box.calls); + ipc_cleanup_call_list(&TASK->kb.box, &TASK->kb.box.dispatched_calls); } @@ -162,5 +168,5 @@ while (!done) { call_t *call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT, - SYNCH_FLAGS_NONE); + SYNCH_FLAGS_NONE); if (call == NULL) @@ -236,5 +242,5 @@ /* Connect the newly allocated phone to the kbox */ - ipc_phone_connect(&TASK->phones[newphid], &task->kb.box); + (void) ipc_phone_connect(&TASK->phones[newphid], &task->kb.box); if (task->kb.thread != NULL) { Index: kernel/generic/src/ipc/ops/clnestab.c =================================================================== --- kernel/generic/src/ipc/ops/clnestab.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/clnestab.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + IPC_SET_ARG5(call->data, (sysarg_t) phone); + + return EOK; +} + +static int answer_cleanup(call_t *answer, ipc_data_t *olddata) +{ + phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); + + mutex_lock(&phone->lock); + if (phone->state == IPC_PHONE_CONNECTED) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); + } + mutex_unlock(&phone->lock); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* + * The other party on the cloned phone rejected our request + * for connection on the protocol level. We need to break the + * connection without sending IPC_M_HUNGUP back. + */ + answer_cleanup(answer, olddata); + } + + return EOK; +} + +sysipc_ops_t ipc_m_clone_establish_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/conctmeto.c =================================================================== --- kernel/generic/src/ipc/ops/conctmeto.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/conctmeto.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + int newphid = phone_alloc(TASK); + + if (newphid < 0) + return ELIMIT; + + /* Set arg5 for server */ + IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]); + call->priv = newphid; + + return EOK; +} + +static int request_forget(call_t *call) +{ + phone_dealloc(call->priv); + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); + + /* If the user accepted call, connect */ + if (IPC_GET_RETVAL(answer->data) == EOK) + (void) ipc_phone_connect(phone, &TASK->answerbox); + + return EOK; +} + +static int answer_process(call_t *answer) +{ + if (IPC_GET_RETVAL(answer->data)) + phone_dealloc(answer->priv); + else + IPC_SET_ARG5(answer->data, answer->priv); + + return EOK; +} + +sysipc_ops_t ipc_m_connect_me_to_ops = { + .request_preprocess = request_preprocess, + .request_forget = request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/concttome.c =================================================================== --- kernel/generic/src/ipc/ops/concttome.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/concttome.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include + +static int request_process(call_t *call, answerbox_t *box) +{ + int phoneid = phone_alloc(TASK); + + IPC_SET_ARG5(call->data, phoneid); + + return EOK; +} + +static int answer_cleanup(call_t *answer, ipc_data_t *olddata) +{ + int phoneid = (int) IPC_GET_ARG5(*olddata); + + if (phoneid >= 0) + phone_dealloc(phoneid); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int phoneid = (int) IPC_GET_ARG5(*olddata); + + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* The connection was not accepted */ + answer_cleanup(answer, olddata); + } else if (phoneid >= 0) { + /* The connection was accepted */ + if (phone_connect(phoneid, &answer->sender->answerbox)) { + /* Set 'phone hash' as arg5 of response */ + IPC_SET_ARG5(answer->data, + (sysarg_t) &TASK->phones[phoneid]); + } else { + /* The answerbox is shutting down. */ + IPC_SET_RETVAL(answer->data, ENOENT); + answer_cleanup(answer, olddata); + } + } else { + IPC_SET_RETVAL(answer->data, ELIMIT); + } + + return EOK; +} + + +sysipc_ops_t ipc_m_connect_to_me_ops = { + .request_preprocess = null_request_preprocess, + .request_forget = null_request_forget, + .request_process = request_process, + .answer_cleanup = answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/connclone.c =================================================================== --- kernel/generic/src/ipc/ops/connclone.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/connclone.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include + +static void phones_lock(phone_t *p1, phone_t *p2) +{ + if (p1 < p2) { + mutex_lock(&p1->lock); + mutex_lock(&p2->lock); + } else if (p1 > p2) { + mutex_lock(&p2->lock); + mutex_lock(&p1->lock); + } else + mutex_lock(&p1->lock); +} + +static void phones_unlock(phone_t *p1, phone_t *p2) +{ + mutex_unlock(&p1->lock); + if (p1 != p2) + mutex_unlock(&p2->lock); +} + +static int request_preprocess(call_t *call, phone_t *phone) +{ + phone_t *cloned_phone; + + if (phone_get(IPC_GET_ARG1(call->data), &cloned_phone) != EOK) + return ENOENT; + + phones_lock(cloned_phone, phone); + + if ((cloned_phone->state != IPC_PHONE_CONNECTED) || + phone->state != IPC_PHONE_CONNECTED) { + phones_unlock(cloned_phone, phone); + return EINVAL; + } + + /* + * We can be pretty sure now that both tasks exist and we are + * connected to them. As we continue to hold the phone locks, + * we are effectively preventing them from finishing their + * potential cleanup. + * + */ + int newphid = phone_alloc(phone->callee->task); + if (newphid < 0) { + phones_unlock(cloned_phone, phone); + return ELIMIT; + } + + (void) ipc_phone_connect(&phone->callee->task->phones[newphid], + cloned_phone->callee); + phones_unlock(cloned_phone, phone); + + /* Set the new phone for the callee. */ + IPC_SET_ARG1(call->data, newphid); + + return EOK; +} + +static int answer_cleanup(call_t *answer, ipc_data_t *olddata) +{ + int phoneid = (int) IPC_GET_ARG1(*olddata); + phone_t *phone = &TASK->phones[phoneid]; + + /* + * In this case, the connection was established at the request + * time and therefore we need to slam the phone. We don't + * merely hangup as that would result in sending IPC_M_HUNGUP + * to the third party on the other side of the cloned phone. + */ + mutex_lock(&phone->lock); + if (phone->state == IPC_PHONE_CONNECTED) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); + } + mutex_unlock(&phone->lock); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* + * The recipient of the cloned phone rejected the offer. + */ + answer_cleanup(answer, olddata); + } + + return EOK; +} + +sysipc_ops_t ipc_m_connection_clone_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/dataread.c =================================================================== --- kernel/generic/src/ipc/ops/dataread.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/dataread.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + size_t size = IPC_GET_ARG2(call->data); + + if (size > DATA_XFER_LIMIT) { + int flags = IPC_GET_ARG3(call->data); + + if (flags & IPC_XF_RESTRICT) + IPC_SET_ARG2(call->data, DATA_XFER_LIMIT); + else + return ELIMIT; + } + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + ASSERT(!answer->buffer); + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient agreed to send data. */ + uintptr_t src = IPC_GET_ARG1(answer->data); + uintptr_t dst = IPC_GET_ARG1(*olddata); + size_t max_size = IPC_GET_ARG2(*olddata); + size_t size = IPC_GET_ARG2(answer->data); + + if (size && size <= max_size) { + /* + * Copy the destination VA so that this piece of + * information is not lost. + */ + IPC_SET_ARG1(answer->data, dst); + + answer->buffer = malloc(size, 0); + int rc = copy_from_uspace(answer->buffer, + (void *) src, size); + if (rc) { + IPC_SET_RETVAL(answer->data, rc); + /* + * answer->buffer will be cleaned up in + * ipc_call_free(). + */ + } + } else if (!size) { + IPC_SET_RETVAL(answer->data, EOK); + } else { + IPC_SET_RETVAL(answer->data, ELIMIT); + } + } + + return EOK; +} + +static int answer_process(call_t *answer) +{ + if (answer->buffer) { + uintptr_t dst = IPC_GET_ARG1(answer->data); + size_t size = IPC_GET_ARG2(answer->data); + int rc; + + rc = copy_to_uspace((void *) dst, answer->buffer, size); + if (rc) + IPC_SET_RETVAL(answer->data, rc); + } + + return EOK; +} + +sysipc_ops_t ipc_m_data_read_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/datawrite.c =================================================================== --- kernel/generic/src/ipc/ops/datawrite.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/datawrite.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + uintptr_t src = IPC_GET_ARG1(call->data); + size_t size = IPC_GET_ARG2(call->data); + + if (size > DATA_XFER_LIMIT) { + int flags = IPC_GET_ARG3(call->data); + + if (flags & IPC_XF_RESTRICT) { + size = DATA_XFER_LIMIT; + IPC_SET_ARG2(call->data, size); + } else + return ELIMIT; + } + + call->buffer = (uint8_t *) malloc(size, 0); + int rc = copy_from_uspace(call->buffer, (void *) src, size); + if (rc != 0) { + /* + * call->buffer will be cleaned up in ipc_call_free() at the + * latest. + */ + return rc; + } + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + ASSERT(answer->buffer); + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient agreed to receive data. */ + uintptr_t dst = (uintptr_t)IPC_GET_ARG1(answer->data); + size_t size = (size_t)IPC_GET_ARG2(answer->data); + size_t max_size = (size_t)IPC_GET_ARG2(*olddata); + + if (size <= max_size) { + int rc = copy_to_uspace((void *) dst, + answer->buffer, size); + if (rc) + IPC_SET_RETVAL(answer->data, rc); + } else { + IPC_SET_RETVAL(answer->data, ELIMIT); + } + } + + return EOK; +} + + +sysipc_ops_t ipc_m_data_write_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/debug.c =================================================================== --- kernel/generic/src/ipc/ops/debug.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/debug.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2008 Jiri Svoboda + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include + +static int request_process(call_t *call, answerbox_t *box) +{ + return -1; +} + +static int answer_process(call_t *answer) +{ + if (answer->buffer) { + uintptr_t dst = IPC_GET_ARG1(answer->data); + size_t size = IPC_GET_ARG2(answer->data); + int rc; + + rc = copy_to_uspace((void *) dst, answer->buffer, size); + if (rc) + IPC_SET_RETVAL(answer->data, rc); + } + + return EOK; +} + +sysipc_ops_t ipc_m_debug_ops = { +#ifdef CONFIG_UDEBUG + .request_preprocess = udebug_request_preprocess, +#else + .request_preprocess = null_request_preprocess, +#endif + .request_forget = null_request_forget, + .request_process = request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = null_answer_preprocess, + .answer_process = answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/sharein.c =================================================================== --- kernel/generic/src/ipc/ops/sharein.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/sharein.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + if (!IPC_GET_RETVAL(answer->data)) { + irq_spinlock_lock(&answer->sender->lock, true); + as_t *as = answer->sender->as; + irq_spinlock_unlock(&answer->sender->lock, true); + + uintptr_t dst_base = (uintptr_t) -1; + int rc = as_area_share(AS, IPC_GET_ARG1(answer->data), + IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data), + &dst_base, IPC_GET_ARG3(answer->data)); + IPC_SET_ARG4(answer->data, dst_base); + IPC_SET_RETVAL(answer->data, rc); + } + + return EOK; +} + +sysipc_ops_t ipc_m_share_in_ops = { + .request_preprocess = null_request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/shareout.c =================================================================== --- kernel/generic/src/ipc/ops/shareout.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/shareout.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + size_t size = as_area_get_size(IPC_GET_ARG1(call->data)); + + if (!size) + return EPERM; + IPC_SET_ARG2(call->data, size); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + if (!IPC_GET_RETVAL(answer->data)) { + /* Accepted, handle as_area receipt */ + + irq_spinlock_lock(&answer->sender->lock, true); + as_t *as = answer->sender->as; + irq_spinlock_unlock(&answer->sender->lock, true); + + uintptr_t dst_base = (uintptr_t) -1; + rc = as_area_share(as, IPC_GET_ARG1(*olddata), + IPC_GET_ARG2(*olddata), AS, IPC_GET_ARG3(*olddata), + &dst_base, IPC_GET_ARG1(answer->data)); + + if (rc == EOK) { + rc = copy_to_uspace((void *) IPC_GET_ARG2(answer->data), + &dst_base, sizeof(dst_base)); + } + + IPC_SET_RETVAL(answer->data, rc); + } + + return rc; +} + +sysipc_ops_t ipc_m_share_out_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/stchngath.c =================================================================== --- kernel/generic/src/ipc/ops/stchngath.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/ops/stchngath.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + phone_t *sender_phone; + task_t *other_task_s; + + if (phone_get(IPC_GET_ARG5(call->data), &sender_phone) != EOK) + return ENOENT; + + mutex_lock(&sender_phone->lock); + if (sender_phone->state != IPC_PHONE_CONNECTED) { + mutex_unlock(&sender_phone->lock); + return EINVAL; + } + + other_task_s = sender_phone->callee->task; + + mutex_unlock(&sender_phone->lock); + + /* Remember the third party task hash. */ + IPC_SET_ARG5(call->data, (sysarg_t) other_task_s); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient authorized the change of state. */ + phone_t *recipient_phone; + task_t *other_task_s; + task_t *other_task_r; + + rc = phone_get(IPC_GET_ARG1(answer->data), + &recipient_phone); + if (rc != EOK) { + IPC_SET_RETVAL(answer->data, ENOENT); + return ENOENT; + } + + mutex_lock(&recipient_phone->lock); + if (recipient_phone->state != IPC_PHONE_CONNECTED) { + mutex_unlock(&recipient_phone->lock); + IPC_SET_RETVAL(answer->data, EINVAL); + return EINVAL; + } + + other_task_r = recipient_phone->callee->task; + other_task_s = (task_t *) IPC_GET_ARG5(*olddata); + + /* + * See if both the sender and the recipient meant the + * same third party task. + */ + if (other_task_r != other_task_s) { + IPC_SET_RETVAL(answer->data, EINVAL); + rc = EINVAL; + } else { + rc = event_task_notify_5(other_task_r, + EVENT_TASK_STATE_CHANGE, false, + IPC_GET_ARG1(*olddata), + IPC_GET_ARG2(*olddata), + IPC_GET_ARG3(*olddata), + LOWER32(olddata->task_id), + UPPER32(olddata->task_id)); + IPC_SET_RETVAL(answer->data, rc); + } + + mutex_unlock(&recipient_phone->lock); + } + + return rc; +} + +sysipc_ops_t ipc_m_state_change_authorize_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/sysipc.c =================================================================== --- kernel/generic/src/ipc/sysipc.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/ipc/sysipc.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -34,12 +34,11 @@ #include -#include -#include #include #include -#include #include #include #include +#include +#include #include #include @@ -47,37 +46,12 @@ #include #include -#include #include #include #include #include -#include #include #include -/** - * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ - * requests. - */ -#define DATA_XFER_LIMIT (64 * 1024) - #define STRUCT_TO_USPACE(dst, src) copy_to_uspace((dst), (src), sizeof(*(src))) - -/** Get phone from the current task by ID. - * - * @param phoneid Phone ID. - * @param phone Place to store pointer to phone. - * - * @return EOK on success, EINVAL if ID is invalid. - * - */ -static int phone_get(sysarg_t phoneid, phone_t **phone) -{ - if (phoneid >= IPC_MAX_PHONES) - return EINVAL; - - *phone = &TASK->phones[phoneid]; - return EOK; -} /** Decide if the interface and method is a system method. @@ -181,235 +155,59 @@ * @param olddata Saved data of the request. * - * @return Return 0 on success or an error code. - * - */ -static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata) -{ + * @return Return EOK on success or a negative error code. + * + */ +int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + spinlock_lock(&answer->forget_lock); + if (answer->forget) { + /* + * This is a forgotten call and answer->sender is not valid. + */ + spinlock_unlock(&answer->forget_lock); + + SYSIPC_OP(answer_cleanup, answer, olddata); + return rc; + } else { + ASSERT(answer->active); + + /* + * Mark the call as inactive to prevent _ipc_answer_free_call() + * from attempting to remove the call from the active list + * itself. + */ + answer->active = false; + + /* + * Remove the call from the sender's active call list. + * We enforce this locking order so that any potential + * concurrently executing forget operation is forced to + * release its active_calls_lock and lose the race to + * forget this soon to be answered call. + */ + spinlock_lock(&answer->sender->active_calls_lock); + list_remove(&answer->ta_link); + spinlock_unlock(&answer->sender->active_calls_lock); + } + spinlock_unlock(&answer->forget_lock); + if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) { - /* In case of forward, hangup the forwared phone, - * not the originator - */ - mutex_lock(&answer->data.phone->lock); - irq_spinlock_lock(&TASK->answerbox.lock, true); - if (answer->data.phone->state == IPC_PHONE_CONNECTED) { - list_remove(&answer->data.phone->link); - answer->data.phone->state = IPC_PHONE_SLAMMED; + phone_t *phone = answer->caller_phone; + mutex_lock(&phone->lock); + if (phone->state == IPC_PHONE_CONNECTED) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); } - irq_spinlock_unlock(&TASK->answerbox.lock, true); - mutex_unlock(&answer->data.phone->lock); + mutex_unlock(&phone->lock); } if (!olddata) - return 0; - - if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECTION_CLONE) { - int phoneid = IPC_GET_ARG1(*olddata); - phone_t *phone = &TASK->phones[phoneid]; - - if (IPC_GET_RETVAL(answer->data) != EOK) { - /* - * The recipient of the cloned phone rejected the offer. - * In this case, the connection was established at the - * request time and therefore we need to slam the phone. - * We don't merely hangup as that would result in - * sending IPC_M_HUNGUP to the third party on the - * other side of the cloned phone. - */ - mutex_lock(&phone->lock); - if (phone->state == IPC_PHONE_CONNECTED) { - irq_spinlock_lock(&phone->callee->lock, true); - list_remove(&phone->link); - phone->state = IPC_PHONE_SLAMMED; - irq_spinlock_unlock(&phone->callee->lock, true); - } - mutex_unlock(&phone->lock); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CLONE_ESTABLISH) { - phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); - - if (IPC_GET_RETVAL(answer->data) != EOK) { - /* - * The other party on the cloned phoned rejected our - * request for connection on the protocol level. - * We need to break the connection without sending - * IPC_M_HUNGUP back. - */ - mutex_lock(&phone->lock); - if (phone->state == IPC_PHONE_CONNECTED) { - irq_spinlock_lock(&phone->callee->lock, true); - list_remove(&phone->link); - phone->state = IPC_PHONE_SLAMMED; - irq_spinlock_unlock(&phone->callee->lock, true); - } - mutex_unlock(&phone->lock); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_TO_ME) { - int phoneid = IPC_GET_ARG5(*olddata); - - if (IPC_GET_RETVAL(answer->data) != EOK) { - /* The connection was not accepted */ - phone_dealloc(phoneid); - } else { - /* The connection was accepted */ - phone_connect(phoneid, &answer->sender->answerbox); - /* Set 'phone hash' as arg5 of response */ - IPC_SET_ARG5(answer->data, - (sysarg_t) &TASK->phones[phoneid]); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_ME_TO) { - /* If the users accepted call, connect */ - if (IPC_GET_RETVAL(answer->data) == EOK) { - ipc_phone_connect((phone_t *) IPC_GET_ARG5(*olddata), - &TASK->answerbox); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_OUT) { - if (!IPC_GET_RETVAL(answer->data)) { - /* Accepted, handle as_area receipt */ - - irq_spinlock_lock(&answer->sender->lock, true); - as_t *as = answer->sender->as; - irq_spinlock_unlock(&answer->sender->lock, true); - - uintptr_t dst_base = (uintptr_t) -1; - int rc = as_area_share(as, IPC_GET_ARG1(*olddata), - IPC_GET_ARG2(*olddata), AS, IPC_GET_ARG3(*olddata), - &dst_base, IPC_GET_ARG1(answer->data)); - - if (rc == EOK) - rc = copy_to_uspace((void *) IPC_GET_ARG2(answer->data), - &dst_base, sizeof(dst_base)); - - IPC_SET_RETVAL(answer->data, rc); - return rc; - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) { - if (!IPC_GET_RETVAL(answer->data)) { - irq_spinlock_lock(&answer->sender->lock, true); - as_t *as = answer->sender->as; - irq_spinlock_unlock(&answer->sender->lock, true); - - uintptr_t dst_base = (uintptr_t) -1; - int rc = as_area_share(AS, IPC_GET_ARG1(answer->data), - IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data), - &dst_base, IPC_GET_ARG3(answer->data)); - IPC_SET_ARG4(answer->data, dst_base); - IPC_SET_RETVAL(answer->data, rc); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_READ) { - ASSERT(!answer->buffer); - if (!IPC_GET_RETVAL(answer->data)) { - /* The recipient agreed to send data. */ - uintptr_t src = IPC_GET_ARG1(answer->data); - uintptr_t dst = IPC_GET_ARG1(*olddata); - size_t max_size = IPC_GET_ARG2(*olddata); - size_t size = IPC_GET_ARG2(answer->data); - if (size && size <= max_size) { - /* - * Copy the destination VA so that this piece of - * information is not lost. - */ - IPC_SET_ARG1(answer->data, dst); - - answer->buffer = malloc(size, 0); - int rc = copy_from_uspace(answer->buffer, - (void *) src, size); - if (rc) { - IPC_SET_RETVAL(answer->data, rc); - free(answer->buffer); - answer->buffer = NULL; - } - } else if (!size) { - IPC_SET_RETVAL(answer->data, EOK); - } else { - IPC_SET_RETVAL(answer->data, ELIMIT); - } - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_WRITE) { - ASSERT(answer->buffer); - if (!IPC_GET_RETVAL(answer->data)) { - /* The recipient agreed to receive data. */ - uintptr_t dst = (uintptr_t)IPC_GET_ARG1(answer->data); - size_t size = (size_t)IPC_GET_ARG2(answer->data); - size_t max_size = (size_t)IPC_GET_ARG2(*olddata); - - if (size <= max_size) { - int rc = copy_to_uspace((void *) dst, - answer->buffer, size); - if (rc) - IPC_SET_RETVAL(answer->data, rc); - } else { - IPC_SET_RETVAL(answer->data, ELIMIT); - } - } - free(answer->buffer); - answer->buffer = NULL; - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_STATE_CHANGE_AUTHORIZE) { - if (!IPC_GET_RETVAL(answer->data)) { - /* The recipient authorized the change of state. */ - phone_t *recipient_phone; - task_t *other_task_s; - task_t *other_task_r; - int rc; - - rc = phone_get(IPC_GET_ARG1(answer->data), - &recipient_phone); - if (rc != EOK) { - IPC_SET_RETVAL(answer->data, ENOENT); - return ENOENT; - } - - mutex_lock(&recipient_phone->lock); - if (recipient_phone->state != IPC_PHONE_CONNECTED) { - mutex_unlock(&recipient_phone->lock); - IPC_SET_RETVAL(answer->data, EINVAL); - return EINVAL; - } - - other_task_r = recipient_phone->callee->task; - other_task_s = (task_t *) IPC_GET_ARG5(*olddata); - - /* - * See if both the sender and the recipient meant the - * same third party task. - */ - if (other_task_r != other_task_s) { - IPC_SET_RETVAL(answer->data, EINVAL); - rc = EINVAL; - } else { - rc = event_task_notify_5(other_task_r, - EVENT_TASK_STATE_CHANGE, false, - IPC_GET_ARG1(*olddata), - IPC_GET_ARG2(*olddata), - IPC_GET_ARG3(*olddata), - LOWER32(olddata->task_id), - UPPER32(olddata->task_id)); - IPC_SET_RETVAL(answer->data, rc); - } - - mutex_unlock(&recipient_phone->lock); - return rc; - } - } - - return 0; -} - -static void phones_lock(phone_t *p1, phone_t *p2) -{ - if (p1 < p2) { - mutex_lock(&p1->lock); - mutex_lock(&p2->lock); - } else if (p1 > p2) { - mutex_lock(&p2->lock); - mutex_lock(&p1->lock); - } else - mutex_lock(&p1->lock); -} - -static void phones_unlock(phone_t *p1, phone_t *p2) -{ - mutex_unlock(&p1->lock); - if (p1 != p2) - mutex_unlock(&p2->lock); + return rc; + + return SYSIPC_OP(answer_preprocess, answer, olddata); } @@ -424,124 +222,6 @@ static int request_preprocess(call_t *call, phone_t *phone) { - switch (IPC_GET_IMETHOD(call->data)) { - case IPC_M_CONNECTION_CLONE: { - phone_t *cloned_phone; - if (phone_get(IPC_GET_ARG1(call->data), &cloned_phone) != EOK) - return ENOENT; - - phones_lock(cloned_phone, phone); - - if ((cloned_phone->state != IPC_PHONE_CONNECTED) || - phone->state != IPC_PHONE_CONNECTED) { - phones_unlock(cloned_phone, phone); - return EINVAL; - } - - /* - * We can be pretty sure now that both tasks exist and we are - * connected to them. As we continue to hold the phone locks, - * we are effectively preventing them from finishing their - * potential cleanup. - * - */ - int newphid = phone_alloc(phone->callee->task); - if (newphid < 0) { - phones_unlock(cloned_phone, phone); - return ELIMIT; - } - - ipc_phone_connect(&phone->callee->task->phones[newphid], - cloned_phone->callee); - phones_unlock(cloned_phone, phone); - - /* Set the new phone for the callee. */ - IPC_SET_ARG1(call->data, newphid); - break; - } - case IPC_M_CLONE_ESTABLISH: - IPC_SET_ARG5(call->data, (sysarg_t) phone); - break; - case IPC_M_CONNECT_ME_TO: { - int newphid = phone_alloc(TASK); - if (newphid < 0) - return ELIMIT; - - /* Set arg5 for server */ - IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]); - call->flags |= IPC_CALL_CONN_ME_TO; - call->priv = newphid; - break; - } - case IPC_M_SHARE_OUT: { - size_t size = as_area_get_size(IPC_GET_ARG1(call->data)); - if (!size) - return EPERM; - - IPC_SET_ARG2(call->data, size); - break; - } - case IPC_M_DATA_READ: { - size_t size = IPC_GET_ARG2(call->data); - if (size > DATA_XFER_LIMIT) { - int flags = IPC_GET_ARG3(call->data); - if (flags & IPC_XF_RESTRICT) - IPC_SET_ARG2(call->data, DATA_XFER_LIMIT); - else - return ELIMIT; - } - break; - } - case IPC_M_DATA_WRITE: { - uintptr_t src = IPC_GET_ARG1(call->data); - size_t size = IPC_GET_ARG2(call->data); - - if (size > DATA_XFER_LIMIT) { - int flags = IPC_GET_ARG3(call->data); - if (flags & IPC_XF_RESTRICT) { - size = DATA_XFER_LIMIT; - IPC_SET_ARG2(call->data, size); - } else - return ELIMIT; - } - - call->buffer = (uint8_t *) malloc(size, 0); - int rc = copy_from_uspace(call->buffer, (void *) src, size); - if (rc != 0) { - free(call->buffer); - return rc; - } - - break; - } - case IPC_M_STATE_CHANGE_AUTHORIZE: { - phone_t *sender_phone; - task_t *other_task_s; - - if (phone_get(IPC_GET_ARG5(call->data), &sender_phone) != EOK) - return ENOENT; - - mutex_lock(&sender_phone->lock); - if (sender_phone->state != IPC_PHONE_CONNECTED) { - mutex_unlock(&sender_phone->lock); - return EINVAL; - } - - other_task_s = sender_phone->callee->task; - - mutex_unlock(&sender_phone->lock); - - /* Remember the third party task hash. */ - IPC_SET_ARG5(call->data, (sysarg_t) other_task_s); - break; - } -#ifdef CONFIG_UDEBUG - case IPC_M_DEBUG: - return udebug_request_preprocess(call, phone); -#endif - default: - break; - } - - return 0; + call->request_method = IPC_GET_IMETHOD(call->data); + return SYSIPC_OP(request_preprocess, call, phone); } @@ -561,26 +241,7 @@ IPC_SET_RETVAL(call->data, EFORWARD); - if (call->flags & IPC_CALL_CONN_ME_TO) { - if (IPC_GET_RETVAL(call->data)) - phone_dealloc(call->priv); - else - IPC_SET_ARG5(call->data, call->priv); - } - - if (call->buffer) { - /* - * This must be an affirmative answer to IPC_M_DATA_READ - * or IPC_M_DEBUG/UDEBUG_M_MEM_READ... - * - */ - uintptr_t dst = IPC_GET_ARG1(call->data); - size_t size = IPC_GET_ARG2(call->data); - int rc = copy_to_uspace((void *) dst, call->buffer, size); - if (rc) - IPC_SET_RETVAL(call->data, rc); - free(call->buffer); - call->buffer = NULL; - } -} + SYSIPC_OP(answer_process, call); +} + /** Do basic kernel processing of received call request. @@ -595,23 +256,5 @@ static int process_request(answerbox_t *box, call_t *call) { - if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME) { - int phoneid = phone_alloc(TASK); - if (phoneid < 0) { /* Failed to allocate phone */ - IPC_SET_RETVAL(call->data, ELIMIT); - ipc_answer(box, call); - return -1; - } - - IPC_SET_ARG5(call->data, phoneid); - } - - switch (IPC_GET_IMETHOD(call->data)) { - case IPC_M_DEBUG: - return -1; - default: - break; - } - - return 0; + return SYSIPC_OP(request_process, call, box); } @@ -745,21 +388,27 @@ { call_t *call = get_call(callid); + phone_t *phone; + bool need_old = answer_need_old(call); + bool after_forward = false; + ipc_data_t old; + int rc; + if (!call) return ENOENT; - + + if (need_old) + old = call->data; + + if (phone_get(phoneid, &phone) != EOK) { + rc = ENOENT; + goto error; + } + + if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) { + rc = EPERM; + goto error; + } + call->flags |= IPC_CALL_FORWARDED; - - phone_t *phone; - if (phone_get(phoneid, &phone) != EOK) { - IPC_SET_RETVAL(call->data, EFORWARD); - ipc_answer(&TASK->answerbox, call); - return ENOENT; - } - - if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) { - IPC_SET_RETVAL(call->data, EFORWARD); - ipc_answer(&TASK->answerbox, call); - return EPERM; - } /* @@ -797,5 +446,21 @@ } - return ipc_forward(call, phone, &TASK->answerbox, mode); + rc = ipc_forward(call, phone, &TASK->answerbox, mode); + if (rc != EOK) { + after_forward = true; + goto error; + } + + return EOK; + +error: + IPC_SET_RETVAL(call->data, EFORWARD); + (void) answer_preprocess(call, need_old ? &old : NULL); + if (after_forward) + _ipc_answer_free_call(call, false); + else + ipc_answer(&TASK->answerbox, call); + + return rc; } Index: kernel/generic/src/ipc/sysipc_ops.c =================================================================== --- kernel/generic/src/ipc/sysipc_ops.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) +++ kernel/generic/src/ipc/sysipc_ops.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * 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 genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include + +/* Forward declarations. */ +sysipc_ops_t ipc_m_connection_clone_ops; +sysipc_ops_t ipc_m_clone_establish_ops; +sysipc_ops_t ipc_m_connect_to_me_ops; +sysipc_ops_t ipc_m_connect_me_to_ops; +sysipc_ops_t ipc_m_share_out_ops; +sysipc_ops_t ipc_m_share_in_ops; +sysipc_ops_t ipc_m_data_write_ops; +sysipc_ops_t ipc_m_data_read_ops; +sysipc_ops_t ipc_m_state_change_authorize_ops; +sysipc_ops_t ipc_m_debug_ops; + +static sysipc_ops_t *sysipc_ops[] = { + [IPC_M_CONNECTION_CLONE] = &ipc_m_connection_clone_ops, + [IPC_M_CLONE_ESTABLISH] = &ipc_m_clone_establish_ops, + [IPC_M_CONNECT_TO_ME] = &ipc_m_connect_to_me_ops, + [IPC_M_CONNECT_ME_TO] = &ipc_m_connect_me_to_ops, + [IPC_M_SHARE_OUT] = &ipc_m_share_out_ops, + [IPC_M_SHARE_IN] = &ipc_m_share_in_ops, + [IPC_M_DATA_WRITE] = &ipc_m_data_write_ops, + [IPC_M_DATA_READ] = &ipc_m_data_read_ops, + [IPC_M_STATE_CHANGE_AUTHORIZE] = &ipc_m_state_change_authorize_ops, + [IPC_M_DEBUG] = &ipc_m_debug_ops +}; + +static sysipc_ops_t null_ops = { + .request_preprocess = null_request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = null_answer_preprocess, + .answer_process = null_answer_process, +}; + +int null_request_preprocess(call_t *call, phone_t *phone) +{ + return EOK; +} + +int null_request_forget(call_t *call) +{ + return EOK; +} + +int null_request_process(call_t *call, answerbox_t *box) +{ + return EOK; +} + +int null_answer_cleanup(call_t *call, ipc_data_t *data) +{ + return EOK; +} + +int null_answer_preprocess(call_t *call, ipc_data_t *data) +{ + return EOK; +} + +int null_answer_process(call_t *call) +{ + return EOK; +} + +sysipc_ops_t *sysipc_ops_get(sysarg_t imethod) +{ + if (imethod < sizeof(sysipc_ops) / (sizeof(sysipc_ops_t *))) + return sysipc_ops[imethod] ? sysipc_ops[imethod] : &null_ops; + + return &null_ops; +} + +/** @} + */ Index: kernel/generic/src/main/kinit.c =================================================================== --- kernel/generic/src/main/kinit.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/main/kinit.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -69,4 +69,5 @@ #include #include +#include #include @@ -179,4 +180,26 @@ program_t programs[CONFIG_INIT_TASKS]; + // FIXME: do not propagate arguments through sysinfo + // but pass them directly to the tasks + for (i = 0; i < init.cnt; i++) { + const char *arguments = init.tasks[i].arguments; + if (str_length(arguments) == 0) + continue; + if (str_length(init.tasks[i].name) == 0) + continue; + size_t arguments_size = str_size(arguments); + + void *arguments_copy = malloc(arguments_size, 0); + if (arguments_copy == NULL) + continue; + memcpy(arguments_copy, arguments, arguments_size); + + char item_name[CONFIG_TASK_NAME_BUFLEN + 15]; + snprintf(item_name, CONFIG_TASK_NAME_BUFLEN + 15, + "init_args.%s", init.tasks[i].name); + + sysinfo_set_item_data(item_name, NULL, arguments_copy, arguments_size); + } + for (i = 0; i < init.cnt; i++) { if (init.tasks[i].paddr % FRAME_SIZE) { Index: kernel/generic/src/mm/as.c =================================================================== --- kernel/generic/src/mm/as.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/mm/as.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -2054,5 +2054,5 @@ { uintptr_t virt = base; - as_area_t *area = as_area_create(AS, flags | AS_AREA_CACHEABLE, size, + as_area_t *area = as_area_create(AS, flags, size, AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound); if (area == NULL) Index: kernel/generic/src/proc/task.c =================================================================== --- kernel/generic/src/proc/task.c (revision 6454ad477434f0d78a622bce7d2aecce3873dc57) +++ kernel/generic/src/proc/task.c (revision c2b2de7ea7c77612cde2379131a6f1e3b0544307) @@ -161,5 +161,8 @@ size_t i; for (i = 0; i < IPC_MAX_PHONES; i++) - ipc_phone_init(&task->phones[i]); + ipc_phone_init(&task->phones[i], task); + + spinlock_initialize(&task->active_calls_lock, "active_calls_lock"); + list_initialize(&task->active_calls); #ifdef CONFIG_UDEBUG @@ -203,4 +206,6 @@ event_task_init(task); + task->answerbox.active = true; + #ifdef CONFIG_UDEBUG /* Init debugging stuff */ @@ -208,4 +213,5 @@ /* Init kbox stuff */ + task->kb.box.active = true; task->kb.finished = false; #endif @@ -213,5 +219,5 @@ if ((ipc_phone_0) && (container_check(ipc_phone_0->task->container, task->container))) - ipc_phone_connect(&task->phones[0], ipc_phone_0); + (void) ipc_phone_connect(&task->phones[0], ipc_phone_0); btree_create(&task->futexes);