Subversion Repositories c0or1k

/*
 * Helper functions that wrap raw l4 syscalls.
 *
 * Copyright (C) 2007-2009 Bahadir Bilgehan Balban
 */
 
#ifndef __L4LIB_SYSLIB_H__
#define __L4LIB_SYSLIB_H__
 
#include <stdio.h>
#include <l4/macros.h>
#include L4LIB_INC_ARCH(syscalls.h)
 
/*
 * NOTE:
 * Its best to use these wrappers because they generalise the way
 * common ipc data like sender id, error, ipc tag are passed
 * between ipc parties.
 *
 * The arguments to l4_ipc() are used by the microkernel to initiate
 * the ipc. Any data passed in message registers may or may not be
 * a duplicate of this data, but the distinction is that anything
 * that is passed via the mrs are meant to be used by the other party
 * participating in the ipc.
 */
 
/* For system call arguments */
#define L4SYS_ARG0	(MR_UNUSED_START)
#define	L4SYS_ARG1	(MR_UNUSED_START + 1)
#define L4SYS_ARG2	(MR_UNUSED_START + 2)
#define L4SYS_ARG3	(MR_UNUSED_START + 3)
 
 
#define L4_IPC_TAG_MASK			0x00000FFF
 
 
/*
 * Servers get sender.
 */
static inline l4id_t l4_get_sender(void)
{
	return (l4id_t)read_mr(MR_SENDER);
}
 
/*
 * When doing an ipc the sender never has to be explicitly set in
 * the utcb via this function since this information is found out
 * by the microkernel by checking the system caller's id. This is
 * only used for restoring the sender on the utcb in order to
 * complete an earlier ipc.
 */
static inline void l4_set_sender(l4id_t sender)
{
	write_mr(MR_SENDER, sender);
}
 
static inline unsigned int l4_set_ipc_size(unsigned int word, unsigned int size)
{
	word &= ~L4_IPC_FLAGS_SIZE_MASK;
	word |= ((size << L4_IPC_FLAGS_SIZE_SHIFT) & L4_IPC_FLAGS_SIZE_MASK);
	return word;
}
 
static inline unsigned int l4_get_ipc_size(unsigned int word)
{
	return (word & L4_IPC_FLAGS_SIZE_MASK) >> L4_IPC_FLAGS_SIZE_SHIFT;
}
 
static inline unsigned int l4_set_ipc_msg_index(unsigned int word, unsigned int index)
{
	/* FIXME: Define MR_PRIMARY_TOTAL, MR_TOTAL etc. and use MR_TOTAL HERE! */
	BUG_ON(index > UTCB_SIZE);
 
	word &= ~L4_IPC_FLAGS_MSG_INDEX_MASK;
	word |= (index << L4_IPC_FLAGS_MSG_INDEX_SHIFT) &
		 L4_IPC_FLAGS_MSG_INDEX_MASK;
	return word;
}
 
static inline unsigned int l4_get_ipc_msg_index(unsigned int word)
{
	return (word & L4_IPC_FLAGS_MSG_INDEX_MASK)
	       >> L4_IPC_FLAGS_MSG_INDEX_SHIFT;
}
 
static inline unsigned int l4_set_ipc_flags(unsigned int word, unsigned int flags)
{
	word &= ~L4_IPC_FLAGS_TYPE_MASK;
	word |= flags & L4_IPC_FLAGS_TYPE_MASK;
	return word;
}
 
static inline unsigned int l4_get_ipc_flags(unsigned int word)
{
	return word & L4_IPC_FLAGS_TYPE_MASK;
}
 
static inline unsigned int l4_get_tag(void)
{
	return read_mr(MR_TAG) & L4_IPC_TAG_MASK;
}
 
static inline void l4_set_tag(unsigned int tag)
{
	unsigned int tag_flags = read_mr(MR_TAG);
 
	tag_flags &= ~L4_IPC_TAG_MASK;
	tag_flags |= tag & L4_IPC_TAG_MASK;
 
	write_mr(MR_TAG, tag_flags);
}
 
/* Servers:
 * Sets the message register for returning errors back to client task.
 * These are usually posix error codes.
 */
static inline void l4_set_retval(int retval)
{
	write_mr(MR_RETURN, retval);
}
 
/* Clients:
 * Learn result of request.
 */
static inline int l4_get_retval(void)
{
	return read_mr(MR_RETURN);
}
 
/*
 * This is useful for stacked IPC. A stacked IPC happens
 * when a new IPC is initiated before concluding the current
 * one.
 *
 * This saves the last ipc's parameters such as the sender
 * and tag information. Any previously saved data in save
 * slots are destroyed. This is fine as IPC stacking is only
 * useful if done once.
 */
static inline void l4_save_ipcregs(void)
{
	l4_get_utcb()->saved_sender = l4_get_sender();
	l4_get_utcb()->saved_tag = l4_get_tag();
}
 
static inline void l4_restore_ipcregs(void)
{
	l4_set_tag(l4_get_utcb()->saved_tag);
	l4_set_sender(l4_get_utcb()->saved_sender);
}
 
#define TASK_CID_MASK			0xFF000000
#define TASK_ID_MASK			0x00FFFFFF
#define TASK_CID_SHIFT			24
 
static inline l4id_t __raw_tid(l4id_t tid)
{
	return tid & TASK_ID_MASK;
}
 
static inline l4id_t __cid(l4id_t tid)
{
	return (tid & TASK_CID_MASK) >> TASK_CID_SHIFT;
}
 
static inline l4id_t self_tid(void)
{
	struct task_ids ids;
 
	l4_getid(&ids);
	return ids.tid;
}
 
static inline l4id_t __raw_self_tid(void)
{
	return __raw_tid(self_tid());
}
 
static inline int l4_send_full(l4id_t to, unsigned int tag)
{
	l4_set_tag(tag);
	return l4_ipc(to, L4_NILTHREAD, L4_IPC_FLAGS_FULL);
}
 
static inline int l4_receive_full(l4id_t from)
{
	return l4_ipc(L4_NILTHREAD, from, L4_IPC_FLAGS_FULL);
}
 
static inline int l4_sendrecv_full(l4id_t to, l4id_t from, unsigned int tag)
{
	int err;
 
	BUG_ON(to == L4_NILTHREAD || from == L4_NILTHREAD);
	l4_set_tag(tag);
 
	err = l4_ipc(to, from, L4_IPC_FLAGS_FULL);
 
	return err;
}
 
static inline int l4_send_extended(l4id_t to, unsigned int tag,
				   unsigned int size, void *buf)
{
	unsigned int flags = 0;
 
	l4_set_tag(tag);
 
	/* Set up flags word for extended ipc */
	flags = l4_set_ipc_flags(flags, L4_IPC_FLAGS_EXTENDED);
	flags = l4_set_ipc_size(flags, size);
	flags = l4_set_ipc_msg_index(flags, L4SYS_ARG0);
 
	/* Write buffer pointer to MR index that we specified */
	write_mr(L4SYS_ARG0, (unsigned long)buf);
 
	return l4_ipc(to, L4_NILTHREAD, flags);
}
 
static inline int l4_receive_extended(l4id_t from, unsigned int size, void *buf)
{
	unsigned int flags = 0;
 
	/* Indicate extended receive */
	flags = l4_set_ipc_flags(flags, L4_IPC_FLAGS_EXTENDED);
 
	/* How much data is accepted */
	flags = l4_set_ipc_size(flags, size);
 
	/* Indicate which MR index buffer pointer is stored */
	flags = l4_set_ipc_msg_index(flags, L4SYS_ARG0);
 
	/* Set MR with buffer to receive data */
	write_mr(L4SYS_ARG0, (unsigned long)buf);
 
	return l4_ipc(L4_NILTHREAD, from, flags);
}
 
/*
 * Return result value as extended IPC.
 *
 * Extended IPC copies up to 2KB user address space buffers.
 * Along with such an ipc, a return value is sent using a primary
 * mr that is used as the return register.
 *
 * It may not be desirable to return a payload on certain conditions,
 * (such as an error return value) So a nopayload field is provided.
 */
static inline int l4_return_extended(int retval, unsigned int size,
				     void *buf, int nopayload)
{
	unsigned int flags = 0;
	l4id_t sender = l4_get_sender();
 
	l4_set_retval(retval);
 
	/* Set up flags word for extended ipc */
	flags = l4_set_ipc_flags(flags, L4_IPC_FLAGS_EXTENDED);
	flags = l4_set_ipc_msg_index(flags, L4SYS_ARG0);
 
	/* Write buffer pointer to MR index that we specified */
	write_mr(L4SYS_ARG0, (unsigned long)buf);
 
	if (nopayload)
		flags = l4_set_ipc_size(flags, 0);
	else
		flags = l4_set_ipc_size(flags, size);
 
	return l4_ipc(sender, L4_NILTHREAD, flags);
}
 
static inline int l4_sendrecv_extended(l4id_t to, l4id_t from,
				       unsigned int tag, void *buf)
{
	/* Need to imitate sendrecv but with extended send/recv flags */
	return 0;
}
 
static inline int l4_send(l4id_t to, unsigned int tag)
{
	l4_set_tag(tag);
 
	return l4_ipc(to, L4_NILTHREAD, 0);
}
 
static inline int l4_sendrecv(l4id_t to, l4id_t from, unsigned int tag)
{
	int err;
 
	BUG_ON(to == L4_NILTHREAD || from == L4_NILTHREAD);
	l4_set_tag(tag);
 
	err = l4_ipc(to, from, 0);
 
	return err;
}
 
static inline int l4_receive(l4id_t from)
{
	return l4_ipc(L4_NILTHREAD, from, 0);
}
 
static inline void l4_print_mrs()
{
	printf("Message registers: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
	       read_mr(0), read_mr(1), read_mr(2), read_mr(3),
	       read_mr(4), read_mr(5));
}
 
/* Servers:
 * Return the ipc result back to requesting task.
 */
static inline int l4_ipc_return(int retval)
{
	l4id_t sender = l4_get_sender();
 
	l4_set_retval(retval);
 
	/* Setting the tag would overwrite retval so we l4_send without tagging */
	return l4_ipc(sender, L4_NILTHREAD, 0);
}
 
void *l4_new_virtual(int npages);
void *l4_del_virtual(void *virt, int npages);
 
/* A helper that translates and maps a physical address to virtual */
static inline void *l4_map_helper(void *phys, int npages)
{
	struct task_ids ids;
	int err;
 
	void *virt = l4_new_virtual(npages);
 
	l4_getid(&ids);
 
	if ((err = l4_map(phys, virt, npages,
			  MAP_USR_DEFAULT, ids.tid)) < 0)
		return PTR_ERR(err);
 
	return virt;
}
 
 
/* A helper that translates and maps a physical address to virtual */
static inline void *l4_unmap_helper(void *virt, int npages)
{
	struct task_ids ids;
 
	l4_getid(&ids);
	l4_unmap(virt, npages, ids.tid);
	l4_del_virtual(virt, npages);
	return 0;
}
 
#define L4_EXIT_MASK		0xFFFF
 
static inline void l4_exit(unsigned int exit_code)
{
	struct task_ids ids;
	l4_getid(&ids);
	l4_thread_control(THREAD_DESTROY |
			  (exit_code & L4_EXIT_MASK),
			  &ids);
}
 
#endif /* __L4LIB_SYSLIB_H__ */