Subversion Repositories c0or1k

/*
 * Inter-process communication
 *
 * Copyright (C) 2007-2009 Bahadir Bilgehan Balban
 */
#include <l4/generic/tcb.h>
#include <l4/lib/mutex.h>
#include <l4/api/ipc.h>
#include <l4/api/thread.h>
#include <l4/api/kip.h>
#include <l4/api/errno.h>
#include <l4/lib/bit.h>
#include <l4/lib/math.h>
#include INC_API(syscall.h)
#include INC_GLUE(message.h)
#include INC_GLUE(ipc.h)
 
int ipc_short_copy(struct ktcb *to, struct ktcb *from)
{
	unsigned int *mr0_src = KTCB_REF_MR0(from);
	unsigned int *mr0_dst = KTCB_REF_MR0(to);
 
	/* NOTE:
	 * Make sure MR_TOTAL matches the number of registers saved on stack.
	 */
	memcpy(mr0_dst, mr0_src, MR_TOTAL * sizeof(unsigned int));
 
	return 0;
}
 
 
/* Copy full utcb region from one task to another. */
int ipc_full_copy(struct ktcb *to, struct ktcb *from)
{
	struct utcb *from_utcb = (struct utcb *)from->utcb_address;
	struct utcb *to_utcb = (struct utcb *)to->utcb_address;
	int ret;
 
	/* First do the short copy of primary mrs */
	if ((ret = ipc_short_copy(to, from)) < 0)
		return ret;
 
	/* Check that utcb memory accesses won't fault us */
	if ((ret = tcb_check_and_lazy_map_utcb(to, 1)) < 0)
		return ret;
	if ((ret = tcb_check_and_lazy_map_utcb(from, 1)) < 0)
		return ret;
 
	/* Directly copy from one utcb to another */
	memcpy(to_utcb->mr_rest, from_utcb->mr_rest,
	       MR_REST * sizeof(unsigned int));
 
	return 0;
}
 
/*
 * Extended copy is asymmetric in that the copying always occurs from
 * the sender's kernel stack to receivers userspace buffers.
 */
int ipc_extended_copy(struct ktcb *to, struct ktcb *from)
{
	unsigned long size = min(from->extended_ipc_size,
				 to->extended_ipc_size);
 
	/*
	 * Copy from sender's kernel stack buffer
	 * to receiver's kernel stack buffer
	 */
	memcpy(to->extended_ipc_buffer,
	       from->extended_ipc_buffer, size);
 
	return 0;
}
 
/*
 * Copies message registers from one ktcb stack to another. During the return
 * from system call, the registers are popped from the stack. In the future
 * this should be optimised so that they shouldn't even be pushed to the stack
 *
 * This also copies the sender into MR0 in case the receiver receives from
 * L4_ANYTHREAD. This is done for security since the receiver cannot trust
 * the sender info provided by the sender task.
 */
int ipc_msg_copy(struct ktcb *to, struct ktcb *from)
{
	unsigned int recv_ipc_type;
	unsigned int send_ipc_type;
	unsigned int *mr0_dst;
	int ret = 0;
 
       	recv_ipc_type = tcb_get_ipc_type(to);
       	send_ipc_type = tcb_get_ipc_type(from);
 
	/*
	 * Check ipc type flags of both parties and
	 * use the following rules:
	 *
	 * SHORT	SHORT		-> SHORT IPC
	 * FULL		FULL/SHORT	-> FULL IPC
	 * EXTENDED	EXTENDED	-> EXTENDED IPC
	 * EXTENDED	NON-EXTENDED	-> ENOIPC
	 */
 
	switch(recv_ipc_type) {
	case IPC_FLAGS_SHORT:
		if (send_ipc_type == IPC_FLAGS_SHORT)
			ret = ipc_short_copy(to, from);
		if (send_ipc_type == IPC_FLAGS_FULL)
			ret = ipc_full_copy(to, from);
		if (send_ipc_type == IPC_FLAGS_EXTENDED)
			ret = -ENOIPC;
		break;
	case IPC_FLAGS_FULL:
		if (send_ipc_type == IPC_FLAGS_SHORT)
			ret = ipc_full_copy(to, from);
		if (send_ipc_type == IPC_FLAGS_FULL)
			ret = ipc_full_copy(to, from);
		if (send_ipc_type == IPC_FLAGS_EXTENDED)
			ret = -ENOIPC;
		break;
	case IPC_FLAGS_EXTENDED:
		if (send_ipc_type == IPC_FLAGS_EXTENDED)
			/* We do a short copy as well. */
			ret = ipc_short_copy(to, from);
			ret = ipc_extended_copy(to, from);
		if (send_ipc_type == IPC_FLAGS_SHORT)
			ret = -ENOIPC;
		if (send_ipc_type == IPC_FLAGS_FULL)
			ret = -ENOIPC;
		break;
	}
 
	/* Save the sender id in case of ANYTHREAD receiver */
	if (to->expected_sender == L4_ANYTHREAD) {
       		mr0_dst = KTCB_REF_MR0(to);
		mr0_dst[MR_SENDER] = from->tid;
	}
 
	return ret;
}
 
int sys_ipc_control(void)
{
	return -ENOSYS;
}
 
/*
 * Upon an ipc error or exception, the sleeper task is
 * notified of it via flags set by this function.
 */
void ipc_signal_error(struct ktcb *sleeper, int retval)
{
	/*
	 * Only EFAULT and ENOIPC is expected for now
	 */
	BUG_ON(retval != -EFAULT && retval != -ENOIPC);
 
	/*
	 * Set ipc error flag for sleeper.
	 */
	if (retval == -EFAULT)
		sleeper->ipc_flags |= IPC_EFAULT;
	if (retval == -ENOIPC)
		sleeper->ipc_flags |= IPC_ENOIPC;
}
 
/*
 * After an ipc, if current task was the sleeping party,
 * this checks whether errors were signalled, clears
 * the ipc flags and returns the appropriate error code.
 */
int ipc_handle_errors(void)
{
	/* Did we wake up normally or get interrupted */
	if (current->flags & TASK_INTERRUPTED) {
		current->flags &= ~TASK_INTERRUPTED;
		return -EINTR;
	}
 
	/* Did ipc fail with a fault error? */
	if (current->ipc_flags & IPC_EFAULT) {
		current->ipc_flags &= ~IPC_EFAULT;
		return -EFAULT;
	}
 
	/* Did ipc fail with a general ipc error? */
	if (current->ipc_flags & IPC_ENOIPC) {
		current->ipc_flags &= ~IPC_ENOIPC;
		return -ENOIPC;
	}
 
	return 0;
}
 
/*
 * NOTE:
 * Why can we safely copy registers and resume task
 * after we release the locks? Because even if someone
 * tried to interrupt and wake up the other party, they
 * won't be able to, because the task's all hooks to its
 * waitqueue have been removed at that stage.
 */
 
/* Interruptible ipc */
int ipc_send(l4id_t recv_tid, unsigned int flags)
{
	struct ktcb *receiver;
	struct waitqueue_head *wqhs, *wqhr;
	int ret = 0;
 
	if (!(receiver = tcb_find_lock(recv_tid)))
		return -ESRCH;
 
	wqhs = &receiver->wqh_send;
	wqhr = &receiver->wqh_recv;
 
	spin_lock(&wqhs->slock);
	spin_lock(&wqhr->slock);
 
	/* Ready to receive and expecting us? */
	if (receiver->state == TASK_SLEEPING &&
	    receiver->waiting_on == wqhr &&
	    (receiver->expected_sender == current->tid ||
	     receiver->expected_sender == L4_ANYTHREAD)) {
		struct waitqueue *wq = receiver->wq;
 
		/* Remove from waitqueue */
		list_remove_init(&wq->task_list);
		wqhr->sleepers--;
		task_unset_wqh(receiver);
 
		/* Release locks */
		spin_unlock(&wqhr->slock);
		spin_unlock(&wqhs->slock);
 
		/* Copy message registers */
		if ((ret = ipc_msg_copy(receiver, current)) < 0)
			ipc_signal_error(receiver, ret);
 
		// printk("%s: (%d) Waking up (%d)\n", __FUNCTION__,
		//       current->tid, receiver->tid);
 
		/* Wake it up async */
		sched_resume_async(receiver);
 
		/* Release thread lock (protects for delete) */
		spin_unlock(&receiver->thread_lock);
		return ret;
	}
 
	/* The receiver is not ready and/or not expecting us */
	CREATE_WAITQUEUE_ON_STACK(wq, current);
	wqhs->sleepers++;
	list_insert_tail(&wq.task_list, &wqhs->task_list);
	task_set_wqh(current, wqhs, &wq);
	sched_prepare_sleep();
	spin_unlock(&wqhr->slock);
	spin_unlock(&wqhs->slock);
	spin_unlock(&receiver->thread_lock);
	// printk("%s: (%d) waiting for (%d)\n", __FUNCTION__,
	//       current->tid, recv_tid);
	schedule();
 
	return ipc_handle_errors();
}
 
int ipc_recv(l4id_t senderid, unsigned int flags)
{
	struct waitqueue_head *wqhs, *wqhr;
	int ret = 0;
 
	wqhs = &current->wqh_send;
	wqhr = &current->wqh_recv;
 
	/*
	 * Indicate who we expect to receive from,
	 * so senders know.
	 */
	current->expected_sender = senderid;
 
	spin_lock(&wqhs->slock);
	spin_lock(&wqhr->slock);
 
	/* Are there senders? */
	if (wqhs->sleepers > 0) {
		struct waitqueue *wq, *n;
		struct ktcb *sleeper;
 
		BUG_ON(list_empty(&wqhs->task_list));
 
		/* Look for a sender we want to receive from */
		list_foreach_removable_struct(wq, n, &wqhs->task_list, task_list) {
			sleeper = wq->task;
 
			/* Found a sender that we wanted to receive from */
			if ((sleeper->tid == current->expected_sender) ||
			    (current->expected_sender == L4_ANYTHREAD)) {
				list_remove_init(&wq->task_list);
				wqhs->sleepers--;
				task_unset_wqh(sleeper);
				spin_unlock(&wqhr->slock);
				spin_unlock(&wqhs->slock);
 
				/* Copy message registers */
				if ((ret = ipc_msg_copy(current, sleeper)) < 0)
					ipc_signal_error(sleeper, ret);
 
				// printk("%s: (%d) Waking up (%d)\n",
				// __FUNCTION__,
				//       current->tid, sleeper->tid);
				sched_resume_sync(sleeper);
				return ret;
			}
		}
	}
 
	/* The sender is not ready */
	CREATE_WAITQUEUE_ON_STACK(wq, current);
	wqhr->sleepers++;
	list_insert_tail(&wq.task_list, &wqhr->task_list);
	task_set_wqh(current, wqhr, &wq);
	sched_prepare_sleep();
	// printk("%s: (%d) waiting for (%d)\n", __FUNCTION__,
	//       current->tid, current->expected_sender);
	spin_unlock(&wqhr->slock);
	spin_unlock(&wqhs->slock);
	schedule();
 
	return ipc_handle_errors();
}
 
/*
 * Both sends and receives mregs in the same call. This is mainly by user
 * tasks for client server communication with system servers.
 *
 * Timeline of client/server communication using ipc_sendrecv():
 *
 * (1) User task (client) calls ipc_sendrecv();
 * (2) System task (server) calls ipc_recv() with from == ANYTHREAD.
 * (3) Rendezvous occurs. Both tasks exchange mrs and leave rendezvous.
 * (4,5) User task, immediately calls ipc_recv(), expecting a origy from server.
 * (4,5) System task handles the request in userspace.
 * (6) System task calls ipc_send() sending the return result.
 * (7) Rendezvous occurs. Both tasks exchange mrs and leave rendezvous.
 */
int ipc_sendrecv(l4id_t to, l4id_t from, unsigned int flags)
{
	int ret = 0;
 
	if (to == from) {
		/* Send ipc request */
		if ((ret = ipc_send(to, flags)) < 0)
			return ret;
		/*
		 * Get reply. A client would block its server
		 * only very briefly between these calls.
		 */
		if ((ret = ipc_recv(from, flags)) < 0)
			return ret;
	} else {
		printk("%s: Unsupported ipc operation.\n", __FUNCTION__);
		ret = -ENOSYS;
	}
	return ret;
}
 
int ipc_sendrecv_extended(l4id_t to, l4id_t from, unsigned int flags)
{
	return -ENOSYS;
}
 
/*
 * In extended receive, receive buffers are page faulted before engaging
 * in real ipc.
 */
int ipc_recv_extended(l4id_t sendertid, unsigned int flags)
{
	unsigned long msg_index;
	unsigned long ipc_address;
	unsigned int size;
	unsigned int *mr0_current;
	int err;
 
	/*
	 * Obtain primary message register index
	 * containing extended ipc buffer address
	 */
	msg_index = extended_ipc_msg_index(flags);
 
	/* Get the pointer to primary message registers */
       	mr0_current = KTCB_REF_MR0(current);
 
	/* Obtain extended ipc address */
	ipc_address = (unsigned long)mr0_current[msg_index];
 
	/* Obtain extended ipc size */
	size = extended_ipc_msg_size(flags);
 
	/* Check size is good */
	if (size > IPC_EXTENDED_MAX_SIZE)
		return -EINVAL;
 
	/* Set extended ipc copy size */
	current->extended_ipc_size = size;
 
	/* Engage in real ipc to copy to ktcb buffer */
	if ((err = ipc_recv(sendertid, flags)) < 0)
		return err;
 
	/* Page fault user pages if needed */
	if ((err = check_access(ipc_address, size,
				MAP_USR_RW, 1)) < 0)
		return err;
 
	/*
	 * Now copy from ktcb to user buffers
	 */
	memcpy((void *)ipc_address,
	       current->extended_ipc_buffer,
	       current->extended_ipc_size);
 
	return 0;
}
 
/*
 * In extended IPC, userspace buffers are copied to process
 * kernel stack before engaging in real calls ipc. If page fault
 * occurs, only the current process time is consumed.
 */
int ipc_send_extended(l4id_t recv_tid, unsigned int flags)
{
	unsigned long msg_index;
	unsigned long ipc_address;
	unsigned int size;
	unsigned int *mr0_current;
	int err;
 
	/*
	 * Obtain primary message register index
	 * containing extended ipc buffer address
	 */
	msg_index = extended_ipc_msg_index(flags);
 
	/* Get the pointer to primary message registers */
       	mr0_current = KTCB_REF_MR0(current);
 
	/* Obtain extended ipc address */
	ipc_address = (unsigned long)mr0_current[msg_index];
 
	/* Obtain extended ipc size */
	size = extended_ipc_msg_size(flags);
 
	/* Check size is good */
	if (size > IPC_EXTENDED_MAX_SIZE)
		return -EINVAL;
 
	/* Set extended ipc copy size */
	current->extended_ipc_size = size;
 
	/* Page fault those pages on the current task if needed */
	if ((err = check_access(ipc_address, size,
				MAP_USR_RW, 1)) < 0)
		return err;
 
	/*
	 * It is now safe to access user pages.
	 * Copy message from user buffer into current kernel stack
	 */
	memcpy(current->extended_ipc_buffer,
	       (void *)ipc_address, size);
 
	/* Now we can engage in the real ipc */
	return ipc_send(recv_tid, flags);
}
 
 
static inline int __sys_ipc(l4id_t to, l4id_t from,
			    unsigned int ipc_dir, unsigned int flags)
{
	int ret;
 
	if (ipc_flags_get_type(flags) == IPC_FLAGS_EXTENDED) {
		switch (ipc_dir) {
		case IPC_SEND:
			ret = ipc_send_extended(to, flags);
			break;
		case IPC_RECV:
			ret = ipc_recv_extended(from, flags);
			break;
		case IPC_SENDRECV:
			ret = ipc_sendrecv_extended(to, from, flags);
			break;
		case IPC_INVALID:
		default:
			printk("Unsupported ipc operation.\n");
			ret = -ENOSYS;
		}
	} else {
		switch (ipc_dir) {
		case IPC_SEND:
			ret = ipc_send(to, flags);
			break;
		case IPC_RECV:
			ret = ipc_recv(from, flags);
			break;
		case IPC_SENDRECV:
			ret = ipc_sendrecv(to, from, flags);
			break;
		case IPC_INVALID:
		default:
			printk("Unsupported ipc operation.\n");
			ret = -ENOSYS;
		}
	}
	return ret;
}
 
void printk_sysregs(syscall_context_t *regs)
{
	printk("System call registers for tid: %d\n", current->tid);
	printk("R0: %x\n", regs->r0);
	printk("R1: %x\n", regs->r1);
	printk("R2: %x\n", regs->r2);
	printk("R3: %x\n", regs->r3);
	printk("R4: %x\n", regs->r4);
	printk("R5: %x\n", regs->r5);
	printk("R6: %x\n", regs->r6);
	printk("R7: %x\n", regs->r7);
	printk("R8: %x\n", regs->r8);
}
 
/*
 * sys_ipc has multiple functions. In a nutshell:
 * - Copies message registers from one thread to another.
 * - Sends notification bits from one thread to another. - Not there yet.
 * - Synchronises the threads involved in ipc. (i.e. a blocking rendez-vous)
 * - Can propagate messages from third party threads.
 * - A thread can both send and receive on the same call.
 */
int sys_ipc(l4id_t to, l4id_t from, unsigned int flags)
{
	unsigned int ipc_dir = 0;
	int ret = 0;
 
	/* Check arguments */
	if (tid_special_value(from) &&
	    from != L4_ANYTHREAD && from != L4_NILTHREAD) {
		ret = -EINVAL;
		goto error;
	}
 
	if (tid_special_value(to) &&
	    to != L4_ANYTHREAD && to != L4_NILTHREAD) {
		ret = -EINVAL;
		goto error;
	}
 
	/* Cannot send to self, or receive from self */
	if (from == current->tid || to == current->tid) {
		ret = -EINVAL;
		goto error;
	}
 
	/* [0] for Send */
	ipc_dir |= (to != L4_NILTHREAD);
 
	/* [1] for Receive, [1:0] for both */
	ipc_dir |= ((from != L4_NILTHREAD) << 1);
 
	if (ipc_dir == IPC_INVALID) {
		ret = -EINVAL;
		goto error;
	}
 
	/* Everything in place, now check capability */
	if ((ret = cap_ipc_check(to, from, flags, ipc_dir)) < 0)
		return ret;
 
	/* Encode ipc type in task flags */
	tcb_set_ipc_flags(current, flags);
 
	if ((ret = __sys_ipc(to, from, ipc_dir, flags)) < 0)
		goto error;
	return ret;
 
error:
	/*
	 * This is not always an error. For example a send/recv
	 * thread may go to suspension before receive phase.
	 */
	//printk("Erroneous ipc by: %d. from: %d, to: %d, Err: %d\n",
	//	 current->tid, from, to, ret);
	ipc_dir = IPC_INVALID;
	return ret;
}