l4lib changes to accomodate extended and full ipc.

- Added ARM register ipc usage explanation to glue/arm/message.h
- In the current design, the unused r2 register is a system register
  that kernel checks for ipc flags such as:
  - IPC type: e.g. full or extended.
  - In extended IPC, MR index containing message buffer ptr.
  - In extended IPC, message size

include/l4/glue/arm/message.h

@@ -1,12 +1,62 @@
 /*
  * Userspace thread control block
  *
- * Copyright (C) 2007 Bahadir Balban
+ * Copyright (C) 2007-2009 Bahadir Bilgehan Balban
  */
 #ifndef __GLUE_ARM_MESSAGE_H__
 #define __GLUE_ARM_MESSAGE_H__
 
-#include INC_GLUE(memlayout.h)
+/* 
+ * Here's a summary of how ARM registers are used during IPC:
+ *
+ * System registers:
+ * r0 - r2: Passed as arguments to ipc() call. They are the registers
+ * the microkernel will read and they have system-wide meaning.
+ * 
+ * Primary message registers:
+ * r3 - r8: These 6 registers are the primary message registers MR0-MR6
+ * Their format is application-specific, i.e. the microkernel imposes no
+ * format restrictions on them.
+ *
+ * TODO: The only exception is that, for ANYTHREAD receivers the predefined
+ * MR_SENDER is touched by the kernel to indicate the sender. This register
+ * is among the primary MRs and it may be better fit to put it into one of
+ * the system registers.
+ *
+ * l4lib registers: (MR_TAG, MR_SENDER, MR_RETURN)
+ * Some of the primary message registers are used by the l4lib convenience
+ * library for operations necessary on most or all common ipcs. For example
+ * every ipc has a tag that specifies the ipc reason. Also send/receive
+ * operations require a return value. Threads that are open to receive from
+ * all threads require the sender id. These values are passed in predefined
+ * primary message registers, but the microkernel has no knowledge about them.
+ *
+ * System call registers: L4SYS_ARG0 to ARG4.(See syslib.h for definitions)
+ * Finally the rest of the primary message registers are available for
+ * implementing system call arguments. For example the POSIX services use
+ * these arguments to pass posix system call information.
+ *
+ * Secondary Message Registers:
+ * These are non-real registers and are present in the UTCB memory region.
+ * Both real and non-real message registers have a location in the UTCB, but
+ * non-real ones are copied only if the FULL IPC flag is set.
+ *
+ * The big picture:
+ *
+ * r0	System register
+ * r1	System register
+ * r2	System register
+ * r3	Primary MR0	MR_RETURN, MR_TAG	Present in UTCB, Short IPC
+ * r4	Primary MR1	MR_SENDER		Present in UTCB, Short IPC
+ * r5	Primary MR2	L4SYS_ARG0		Present in UTCB, Short IPC
+ * r6	Primary MR3	L4SYS_ARG1		Present in UTCB, Short IPC
+ * r7	Primary MR4	L4SYS_ARG2		Present in UTCB, Short IPC
+ * r8 	Primary MR5	L4SYS_ARG3		Present in UTCB, Short IPC
+ * x	Secondary MR6				Present in UTCB, Full IPC only
+ * x	Secondary MR64				Present in UTCB, Full IPC only
+ *
+ * Complicated for you? Suggest a simpler design and it shall be implemented!
+ */
 
 #define MR_REST			(UTCB_SIZE - MR_TOTAL - 2)	/* -2 is for fields on utcb */
 #define MR_TOTAL		6
@@ -23,4 +73,14 @@
 #define MR0_REGISTER		r3
 #define MR_RETURN_REGISTER	r3
 
+#define L4_IPC_FLAGS_FULL		0x00000001	/* Full IPC involves full UTCB copy */
+#define L4_IPC_FLAGS_EXTENDED		0x00000002	/* Extended IPC can page-fault and copy up to 2KB */
+#define L4_IPC_FLAGS_MSG_INDEX_MASK	0x00000FF0	/* Index of message register with buffer pointer */
+#define L4_IPC_FLAGS_MASK		0x0000000F
+#define L4_IPC_FLAGS_SIZE_MASK		0x0FFF0000
+#define L4_IPC_FLAGS_SIZE_SHIFT		16
+#define L4_IPC_FLAGS_MSG_INDEX_SHIFT	4
+
+#include INC_GLUE(memlayout.h)
+
 #endif /* __GLUE_ARM_MESSAGE_H__ */

tasks/libl4/include/l4lib/arch-arm/syscalls.h

@@ -36,9 +36,9 @@ typedef int (*__l4_getid_t)(struct task_ids *ids);
 extern __l4_getid_t __l4_getid;
 int l4_getid(struct task_ids *ids);
 
-typedef int (*__l4_ipc_t)(l4id_t to, l4id_t from);
+typedef int (*__l4_ipc_t)(l4id_t to, l4id_t from, u32 flags);
 extern __l4_ipc_t __l4_ipc;
-int l4_ipc(l4id_t to, l4id_t from);
+int l4_ipc(l4id_t to, l4id_t from, u32 flags);
 
 typedef int (*__l4_kread_t)(u32 rd, void *addr);
 extern __l4_kread_t __l4_kread;

tasks/libl4/include/l4lib/arch-arm/syslib.h

@@ -1,7 +1,7 @@
 /*
  * Helper functions that wrap raw l4 syscalls.
  *
- * Copyright (C) 2007 Bahadir Balban
+ * Copyright (C) 2007-2009 Bahadir Bilgehan Balban
  */
 
 #ifndef __L4LIB_SYSLIB_H__
@@ -30,6 +30,10 @@
 #define L4SYS_ARG2	(MR_UNUSED_START + 2)
 #define L4SYS_ARG3	(MR_UNUSED_START + 3)
 
+
+#define L4_IPC_TAG_MASK			0x00000FFF
+
+
 /*
  * Servers get sender.
  */
@@ -50,41 +54,45 @@ static inline void l4_set_sender(l4id_t sender)
 	write_mr(MR_SENDER, sender);
 }
 
-#define L4_IPC_FLAGS_FULL		0x00001000	/* Full IPC involves full UTCB copy */
+static inline unsigned int l4_set_ipc_size(unsigned int word, unsigned int size)
-#define L4_IPC_FLAGS_EXTENDED		0x00002000	/* Extended IPC can page-fault and copy up to 2KB */
-#define L4_IPC_FLAGS_MASK		0x0000F000
-#define L4_IPC_TAG_MASK			0x00000FFF
-#define L4_IPC_SIZE_MASK		0x0FFF0000
-#define L4_IPC_SIZE_SHIFT		16
-
-static inline void l4_set_ipc_size(unsigned int size)
 {
-	unsigned int tag_flags = read_mr(MR_TAG);
+	word &= ~L4_IPC_FLAGS_SIZE_MASK;
-
+	word |= ((size << L4_IPC_FLAGS_SIZE_SHIFT) & L4_IPC_FLAGS_SIZE_MASK);
-	tag_flags &= ~L4_IPC_SIZE_MASK;
+	return word;
-	tag_flags |= ((size << L4_IPC_SIZE_SHIFT) & L4_IPC_SIZE_MASK);
-
-	write_mr(MR_TAG, size);
 }
 
-static inline unsigned int l4_get_ipc_size(void)
+static inline unsigned int l4_get_ipc_size(unsigned int word)
 {
-	return (read_mr(MR_TAG) >> L4_IPC_SIZE_SHIFT) & L4_IPC_SIZE_MASK;
+	return (word & L4_IPC_FLAGS_SIZE_MASK) >> L4_IPC_FLAGS_SIZE_SHIFT;
 }
 
-static inline void l4_set_ipc_flags(unsigned int flags)
+static inline unsigned int l4_set_ipc_msg_index(unsigned int word, unsigned int index)
 {
-	unsigned int tag_flags = read_mr(MR_TAG);
+	/* FIXME: Define MR_PRIMARY_TOTAL, MR_TOTAL etc. and use MR_TOTAL HERE! */
+	BUG_ON(index > UTCB_SIZE);
 
-	tag_flags &= ~L4_IPC_FLAGS_MASK;
+	word &= ~L4_IPC_FLAGS_MSG_INDEX_MASK;
-	tag_flags |= L4_IPC_FLAGS_MASK & flags;
+	word |= (index << L4_IPC_FLAGS_MSG_INDEX_SHIFT) &
-
+		 L4_IPC_FLAGS_MSG_INDEX_MASK;
-	write_mr(MR_TAG, tag_flags);
+	return word;
 }
 
-static inline unsigned int l4_get_ipc_flags(unsigned int flags)
+static inline unsigned int l4_get_ipc_msg_index(unsigned int word)
 {
-	return read_mr(MR_TAG) & L4_IPC_FLAGS_MASK;
+	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_MASK;
+	word |= flags & L4_IPC_FLAGS_MASK;
+	return word;
+}
+
+static inline unsigned int l4_get_ipc_flags(unsigned int word)
+{
+	return word & L4_IPC_FLAGS_MASK;
 }
 
 static inline unsigned int l4_get_tag(void)
@@ -129,43 +137,64 @@ static inline l4id_t self_tid(void)
 
 static inline int l4_send_full(l4id_t to, unsigned int tag)
 {
-	l4_set_ipc_flags(L4_IPC_FLAGS_FULL);
 	l4_set_tag(tag);
-	return l4_ipc(to, L4_NILTHREAD);
+	return l4_ipc(to, L4_NILTHREAD, L4_IPC_FLAGS_FULL);
 }
 
 static inline int l4_receive_full(l4id_t from)
 {
-	l4_set_ipc_flags(L4_IPC_FLAGS_FULL);
+	return l4_ipc(L4_NILTHREAD, from, L4_IPC_FLAGS_FULL);
-	return l4_ipc(L4_NILTHREAD, from);
 }
 
 static inline int l4_send_extended(l4id_t to, unsigned int tag,
 				   unsigned int size, void *buf)
 {
-	l4_set_tag(tag);
+	unsigned int flags = 0;
-	l4_set_ipc_flags(L4_IPC_FLAGS_EXTENDED);
-	l4_set_ipc_size(size);
 
+	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);
+	return l4_ipc(to, L4_NILTHREAD, flags);
 }
 
 static inline int l4_receive_extended(l4id_t from, unsigned int size, void *buf)
 {
-	l4_set_ipc_flags(L4_IPC_FLAGS_EXTENDED);/* Indicate extended receive */
+	unsigned int flags = 0;
-	l4_set_ipc_size(size);			/* How much data is accepted */
+
-	write_mr(L4SYS_ARG0, (unsigned long)buf);  /* Buffer to receive data */
+	/* Indicate extended receive */
-	return l4_ipc(L4_NILTHREAD, from);
+	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);
 }
 
+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);
+	return l4_ipc(to, L4_NILTHREAD, 0);
 }
 
 static inline int l4_sendrecv(l4id_t to, l4id_t from, unsigned int tag)
@@ -175,14 +204,14 @@ static inline int l4_sendrecv(l4id_t to, l4id_t from, unsigned int tag)
 	BUG_ON(to == L4_NILTHREAD || from == L4_NILTHREAD);
 	l4_set_tag(tag);
 
-	err = l4_ipc(to, from);
+	err = l4_ipc(to, from, 0);
 
 	return err;
 }
 
 static inline int l4_receive(l4id_t from)
 {
-	return l4_ipc(L4_NILTHREAD, from);
+	return l4_ipc(L4_NILTHREAD, from, 0);
 }
 
 /* Servers:
@@ -220,7 +249,7 @@ static inline int l4_ipc_return(int retval)
 	l4_set_retval(retval);
 
 	/* Setting the tag may overwrite retval so we l4_send without tagging */
-	return l4_ipc(sender, L4_NILTHREAD);
+	return l4_ipc(sender, L4_NILTHREAD, 0);
 }
 
 /* A helper that translates and maps a physical address to virtual */