Messages in this thread Patch in this message | | | Date | Wed, 28 Feb 2007 22:41:17 +0100 | From | Ingo Molnar <> | Subject | [patch 02/12] syslets: add syslet.h include file, user API/ABI definitions |
| |
From: Ingo Molnar <mingo@elte.hu>
add include/linux/syslet.h which contains the user-space API/ABI declarations. Add the new header to include/linux/Kbuild as well.
Signed-off-by: Ingo Molnar <mingo@elte.hu> Signed-off-by: Arjan van de Ven <arjan@linux.intel.com> --- include/linux/Kbuild | 1 include/linux/syslet.h | 155 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 156 insertions(+)
Index: linux/include/linux/Kbuild =================================================================== --- linux.orig/include/linux/Kbuild +++ linux/include/linux/Kbuild @@ -141,6 +141,7 @@ header-y += sockios.h header-y += som.h header-y += sound.h header-y += synclink.h +header-y += syslet.h header-y += telephony.h header-y += termios.h header-y += ticable.h Index: linux/include/linux/syslet.h =================================================================== --- /dev/null +++ linux/include/linux/syslet.h @@ -0,0 +1,155 @@ +#ifndef _LINUX_SYSLET_H +#define _LINUX_SYSLET_H +/* + * The syslet subsystem - asynchronous syscall execution support. + * + * Started by Ingo Molnar: + * + * Copyright (C) 2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> + * + * User-space API/ABI definitions: + */ + +#ifndef __user +# define __user +#endif + +/* + * This is the 'Syslet Atom' - the basic unit of execution + * within the syslet framework. A syslet always represents + * a single system-call plus its arguments, plus has conditions + * attached to it that allows the construction of larger + * programs from these atoms. User-space variables can be used + * (for example a loop index) via the special sys_umem*() syscalls. + * + * Arguments are implemented via pointers to arguments. This not + * only increases the flexibility of syslet atoms (multiple syslets + * can share the same variable for example), but is also an + * optimization: copy_uatom() will only fetch syscall parameters + * up until the point it meets the first NULL pointer. 50% of all + * syscalls have 2 or less parameters (and 90% of all syscalls have + * 4 or less parameters). + * + * [ Note: since the argument array is at the end of the atom, and the + * kernel will not touch any argument beyond the final NULL one, atoms + * might be packed more tightly. (the only special case exception to + * this rule would be SKIP_TO_NEXT_ON_STOP atoms, where the kernel will + * jump a full syslet_uatom number of bytes.) ] + */ +struct syslet_uatom { + u32 flags; + u32 nr; + u64 ret_ptr; + u64 next; + u64 arg_ptr[6]; + /* + * User-space can put anything in here, kernel will not + * touch it: + */ + u64 private; +}; + +/* + * Flags to modify/control syslet atom behavior: + */ + +/* + * Immediately queue this syslet asynchronously - do not even + * attempt to execute it synchronously in the user context: + */ +#define SYSLET_ASYNC 0x00000001 + +/* + * Never queue this syslet asynchronously - even if synchronous + * execution causes a context-switching: + */ +#define SYSLET_SYNC 0x00000002 + +/* + * Do not queue the syslet in the completion ring when done. + * + * ( the default is that the final atom of a syslet is queued + * in the completion ring. ) + * + * Some syscalls generate implicit completion events of their + * own. + */ +#define SYSLET_NO_COMPLETE 0x00000004 + +/* + * Execution control: conditions upon the return code + * of the just executed syslet atom. 'Stop' means syslet + * execution is stopped and the atom is put into the + * completion ring: + */ +#define SYSLET_STOP_ON_NONZERO 0x00000008 +#define SYSLET_STOP_ON_ZERO 0x00000010 +#define SYSLET_STOP_ON_NEGATIVE 0x00000020 +#define SYSLET_STOP_ON_NON_POSITIVE 0x00000040 + +#define SYSLET_STOP_MASK \ + ( SYSLET_STOP_ON_NONZERO | \ + SYSLET_STOP_ON_ZERO | \ + SYSLET_STOP_ON_NEGATIVE | \ + SYSLET_STOP_ON_NON_POSITIVE ) + +/* + * Special modifier to 'stop' handling: instead of stopping the + * execution of the syslet, the linearly next syslet is executed. + * (Normal execution flows along atom->next, and execution stops + * if atom->next is NULL or a stop condition becomes true.) + * + * This is what allows true branches of execution within syslets. + */ +#define SYSLET_SKIP_TO_NEXT_ON_STOP 0x00000080 + +/* + * This is the (per-user-context) descriptor of the async completion + * ring. This gets passed in to sys_async_exec(): + */ +struct async_head_user { + /* + * Current completion ring index - managed by the kernel: + */ + u64 kernel_ring_idx; + /* + * User-side ring index: + */ + u64 user_ring_idx; + + /* + * Ring of pointers to completed async syslets (i.e. syslets that + * generated a cachemiss and went async, returning -EASYNCSYSLET + * to the user context by sys_async_exec()) are queued here. + * Syslets that were executed synchronously (cached) are not + * queued here. + * + * Note: the final atom that generated the exit condition is + * queued here. Normally this would be the last atom of a syslet. + */ + u64 completion_ring_ptr; + + /* + * Ring size in bytes: + */ + u64 ring_size_bytes; + + /* + * The head task can become a cachemiss thread later on + * too, if it blocks - so it needs its separate thread + * stack and start address too: + */ + u64 head_stack; + u64 head_ip; + + /* + * Newly started async kernel threads will take their + * user stack and user start address from here. User-space + * code has to check for new_thread_stack going to NULL + * and has to refill it with a new stack if that happens. + */ + u64 new_thread_stack; + u64 new_thread_ip; +}; + +#endif - To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
| |