syslet.h

   1 #ifndef _LINUX_SYSLET_H
   2 #define _LINUX_SYSLET_H
   3 /*
   4  * The syslet subsystem - asynchronous syscall execution support.
   5  *
   6  * Started by Ingo Molnar:
   7  *
   8  *  Copyright (C) 2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
   9  *
  10  * User-space API/ABI definitions:
  11  */
  12
  13 #ifndef __user
  14 # define __user
  15 #endif
  16
  17 /*
  18  * This is the 'Syslet Atom' - the basic unit of execution
  19  * within the syslet framework. A syslet always represents
  20  * a single system-call plus its arguments, plus has conditions
  21  * attached to it that allows the construction of larger
  22  * programs from these atoms. User-space variables can be used
  23  * (for example a loop index) via the special sys_umem*() syscalls.
  24  *
  25  * Arguments are implemented via pointers to arguments. This not
  26  * only increases the flexibility of syslet atoms (multiple syslets
  27  * can share the same variable for example), but is also an
  28  * optimization: copy_uatom() will only fetch syscall parameters
  29  * up until the point it meets the first NULL pointer. 50% of all
  30  * syscalls have 2 or less parameters (and 90% of all syscalls have
  31  * 4 or less parameters).
  32  *
  33  * [ Note: since the argument array is at the end of the atom, and the
  34  *   kernel will not touch any argument beyond the final NULL one, atoms
  35  *   might be packed more tightly. (the only special case exception to
  36  *   this rule would be SKIP_TO_NEXT_ON_STOP atoms, where the kernel will
  37  *   jump a full syslet_uatom number of bytes.) ]
  38  */
  39 struct syslet_uatom {
  40         unsigned long                           flags;
  41         unsigned long                           nr;
  42         long __user                             *ret_ptr;
  43         struct syslet_uatom     __user          *next;
  44         unsigned long           __user          *arg_ptr[6];
  45         /*
  46          * User-space can put anything in here, kernel will not
  47          * touch it:
  48          */
  49         void __user                             *private;
  50 };
  51
  52 /*
  53  * Flags to modify/control syslet atom behavior:
  54  */
  55
  56 /*
  57  * Immediately queue this syslet asynchronously - do not even
  58  * attempt to execute it synchronously in the user context:
  59  */
  60 #define SYSLET_ASYNC                            0x00000001
  61
  62 /*
  63  * Never queue this syslet asynchronously - even if synchronous
  64  * execution causes a context-switching:
  65  */
  66 #define SYSLET_SYNC                             0x00000002
  67
  68 /*
  69  * Do not queue the syslet in the completion ring when done.
  70  *
  71  * ( the default is that the final atom of a syslet is queued
  72  *   in the completion ring. )
  73  *
  74  * Some syscalls generate implicit completion events of their
  75  * own.
  76  */
  77 #define SYSLET_NO_COMPLETE                      0x00000004
  78
  79 /*
  80  * Execution control: conditions upon the return code
  81  * of the just executed syslet atom. 'Stop' means syslet
  82  * execution is stopped and the atom is put into the
  83  * completion ring:
  84  */
  85 #define SYSLET_STOP_ON_NONZERO                  0x00000008
  86 #define SYSLET_STOP_ON_ZERO                     0x00000010
  87 #define SYSLET_STOP_ON_NEGATIVE                 0x00000020
  88 #define SYSLET_STOP_ON_NON_POSITIVE             0x00000040
  89
  90 #define SYSLET_STOP_MASK                                \
  91         (       SYSLET_STOP_ON_NONZERO          |       \
  92                 SYSLET_STOP_ON_ZERO             |       \
  93                 SYSLET_STOP_ON_NEGATIVE         |       \
  94                 SYSLET_STOP_ON_NON_POSITIVE             )
  95
  96 /*
  97  * Special modifier to 'stop' handling: instead of stopping the
  98  * execution of the syslet, the linearly next syslet is executed.
  99  * (Normal execution flows along atom->next, and execution stops
 100  *  if atom->next is NULL or a stop condition becomes true.)
 101  *
 102  * This is what allows true branches of execution within syslets.
 103  */
 104 #define SYSLET_SKIP_TO_NEXT_ON_STOP             0x00000080
 105
 106 /*
 107  * This is the (per-user-context) descriptor of the async completion
 108  * ring. This gets passed in to sys_async_exec():
 109  */
 110 struct async_head_user {
 111         /*
 112          * Current completion ring index - managed by the kernel:
 113          */
 114         unsigned long                           kernel_ring_idx;
 115         /*
 116          * User-side ring index:
 117          */
 118         unsigned long                           user_ring_idx;
 119
 120         /*
 121          * Ring of pointers to completed async syslets (i.e. syslets that
 122          * generated a cachemiss and went async, returning -EASYNCSYSLET
 123          * to the user context by sys_async_exec()) are queued here.
 124          * Syslets that were executed synchronously (cached) are not
 125          * queued here.
 126          *
 127          * Note: the final atom that generated the exit condition is
 128          * queued here. Normally this would be the last atom of a syslet.
 129          */
 130         struct syslet_uatom __user              **completion_ring;
 131
 132         /*
 133          * Ring size in bytes:
 134          */
 135         unsigned long                           ring_size_bytes;
 136
 137         /*
 138          * The head task can become a cachemiss thread later on
 139          * too, if it blocks - so it needs its separate thread
 140          * stack and start address too:
 141          */
 142         unsigned long                           head_stack;
 143         unsigned long                           head_eip;
 144
 145         /*
 146          * Newly started async kernel threads will take their
 147          * user stack and user start address from here. User-space
 148          * code has to check for new_thread_stack going to NULL
 149          * and has to refill it with a new stack if that happens.
 150          */
 151         unsigned long                           new_thread_stack;
 152         unsigned long                           new_thread_eip;
 153 };
 154
 155 #endif