kitten/user/liblwk/syscalls.c

   1 /* Copyright (c) 2008, Sandia National Laboratories */
   2
   3 #include <lwk/unistd.h>
   4 #include <lwk/liblwk.h>
   5
   6 /**
   7  * There is no way to specify inline assembly constraints for %r10 (arg4),
   8  * %r8 (arg5), and %r9 (arg6), so the macros below specify the registers
   9  * to use for local variables as a work-around.
  10  *
  11  * GCC BUG? -- For some unknown reason, the register specified to store
  12  *             a local variable is not always honored if the variable
  13  *             is assigned when it is declared.  Work-around by declaring
  14  *             and assigning on separate lines.
  15  */
  16 #define SYSCALL0(name)                                          \
  17 int name(void) {                                                \
  18         int status;                                             \
  19         asm volatile(                                           \
  20                 "syscall"                                       \
  21                 : "=a" (status)                                 \
  22                 : "0" (__NR_##name)                             \
  23                 : "memory", "rcx", "r11", "cc"                  \
  24         );                                                      \
  25         return status;                                          \
  26 }
  27
  28 #define SYSCALL1(name, type1)                                   \
  29 int name(type1 arg1) {                                          \
  30         int status;                                             \
  31         register type1 rdi asm("rdi");                          \
  32         rdi = arg1;                                             \
  33         asm volatile(                                           \
  34                 "syscall"                                       \
  35                 : "=a" (status)                                 \
  36                 : "0" (__NR_##name),                            \
  37                   "r" (rdi)                                     \
  38                 : "memory", "rcx", "r11", "cc"                  \
  39         );                                                      \
  40         return status;                                          \
  41 }
  42
  43 #define SYSCALL2(name, type1, type2)                            \
  44 int name(type1 arg1, type2 arg2) {                              \
  45         int status;                                             \
  46         register type1 rdi asm("rdi");                          \
  47         register type2 rsi asm("rsi");                          \
  48         rdi = arg1;                                             \
  49         rsi = arg2;                                             \
  50         asm volatile(                                           \
  51                 "syscall"                                       \
  52                 : "=a" (status)                                 \
  53                 : "0" (__NR_##name),                            \
  54                   "r" (rdi),                                    \
  55                   "r" (rsi)                                     \
  56                 : "memory", "rcx", "r11", "cc"                  \
  57         );                                                      \
  58         return status;                                          \
  59 }
  60
  61 #define SYSCALL3(name, type1, type2, type3)                     \
  62 int name(type1 arg1, type2 arg2, type3 arg3) {                  \
  63         int status;                                             \
  64         register type1 rdi asm("rdi");                          \
  65         register type2 rsi asm("rsi");                          \
  66         register type3 rdx asm("rdx");                          \
  67         rdi = arg1;                                             \
  68         rsi = arg2;                                             \
  69         rdx = arg3;                                             \
  70         asm volatile(                                           \
  71                 "syscall"                                       \
  72                 : "=a" (status)                                 \
  73                 : "0" (__NR_##name),                            \
  74                   "r" (rdi),                                    \
  75                   "r" (rsi),                                    \
  76                   "r" (rdx)                                     \
  77                 : "memory", "rcx", "r11", "cc"                  \
  78         );                                                      \
  79         return status;                                          \
  80 }
  81
  82 #define SYSCALL4(name, type1, type2, type3, type4)              \
  83 int name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {      \
  84         int status;                                             \
  85         register type1 rdi asm("rdi");                          \
  86         register type2 rsi asm("rsi");                          \
  87         register type3 rdx asm("rdx");                          \
  88         register type4 r10 asm("r10");                          \
  89         rdi = arg1;                                             \
  90         rsi = arg2;                                             \
  91         rdx = arg3;                                             \
  92         r10 = arg4;                                             \
  93         asm volatile(                                           \
  94                 "syscall"                                       \
  95                 : "=a" (status)                                 \
  96                 : "0" (__NR_##name),                            \
  97                   "r" (rdi),                                    \
  98                   "r" (rsi),                                    \
  99                   "r" (rdx),                                    \
 100                   "r" (r10)                                     \
 101                 : "memory", "rcx", "r11", "cc"                  \
 102         );                                                      \
 103         return status;                                          \
 104 }
 105
 106 #define SYSCALL5(name, type1, type2, type3, type4, type5)       \
 107 int name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,        \
 108          type5 arg5) {                                          \
 109         int status;                                             \
 110         register type1 rdi asm("rdi");                          \
 111         register type2 rsi asm("rsi");                          \
 112         register type3 rdx asm("rdx");                          \
 113         register type4 r10 asm("r10");                          \
 114         register type5 r8  asm("r8");                           \
 115         rdi = arg1;                                             \
 116         rsi = arg2;                                             \
 117         rdx = arg3;                                             \
 118         r10 = arg4;                                             \
 119         r8  = arg5;                                             \
 120         asm volatile(                                           \
 121                 "syscall"                                       \
 122                 : "=a" (status)                                 \
 123                 : "0" (__NR_##name),                            \
 124                   "r" (rdi),                                    \
 125                   "r" (rsi),                                    \
 126                   "r" (rdx),                                    \
 127                   "r" (r10),                                    \
 128                   "r" (r8)                                      \
 129                 : "memory", "rcx", "r11", "cc"                  \
 130         );                                                      \
 131         return status;                                          \
 132 }
 133
 134 #define SYSCALL6(name, type1, type2, type3, type4, type5, type6)\
 135 int name(type1 arg1, type2 arg2, type3 arg3, type4 arg4,        \
 136          type5 arg5, type6 arg6) {                              \
 137         int status;                                             \
 138         register type1 rdi asm("rdi");                          \
 139         register type2 rsi asm("rsi");                          \
 140         register type3 rdx asm("rdx");                          \
 141         register type4 r10 asm("r10");                          \
 142         register type5 r8  asm("r8");                           \
 143         register type6 r9  asm("r9");                           \
 144         rdi = arg1;                                             \
 145         rsi = arg2;                                             \
 146         rdx = arg3;                                             \
 147         r10 = arg4;                                             \
 148         r8  = arg5;                                             \
 149         r9  = arg6;                                             \
 150         asm volatile(                                           \
 151                 "syscall"                                       \
 152                 : "=a" (status)                                 \
 153                 : "0" (__NR_##name),                            \
 154                   "r" (rdi),                                    \
 155                   "r" (rsi),                                    \
 156                   "r" (rdx),                                    \
 157                   "r" (r10),                                    \
 158                   "r" (r8),                                     \
 159                   "r" (r9)                                      \
 160                 : "memory", "rcx", "r11", "cc"                  \
 161         );                                                      \
 162         return status;                                          \
 163 }
 164
 165 /**
 166  * Physical memory management.
 167  */
 168 SYSCALL1(pmem_add, const struct pmem_region *);
 169 SYSCALL1(pmem_update, const struct pmem_region *);
 170 SYSCALL2(pmem_query, const struct pmem_region *, struct pmem_region *);
 171 SYSCALL4(pmem_alloc, size_t, size_t,
 172          const struct pmem_region *, struct pmem_region *);
 173
 174 /**
 175  * Address space management.
 176  */
 177 SYSCALL1(aspace_get_myid, id_t *);
 178 SYSCALL3(aspace_create, id_t, const char *, id_t *);
 179 SYSCALL1(aspace_destroy, id_t);
 180 SYSCALL5(aspace_find_hole, id_t, vaddr_t, size_t, size_t, vaddr_t *);
 181 SYSCALL6(aspace_add_region,
 182          id_t, vaddr_t, size_t, vmflags_t, vmpagesize_t, const char *);
 183 SYSCALL3(aspace_del_region, id_t, vaddr_t, size_t);
 184 SYSCALL4(aspace_map_pmem, id_t, paddr_t, vaddr_t, size_t);
 185 SYSCALL3(aspace_unmap_pmem, id_t, vaddr_t, size_t);
 186 SYSCALL4(aspace_smartmap, id_t, id_t, vaddr_t, size_t);
 187 SYSCALL2(aspace_unsmartmap, id_t, id_t);
 188 SYSCALL1(aspace_dump2console, id_t);
 189
 190 /**
 191  * Task management.
 192  */
 193 SYSCALL1(task_get_myid, id_t *);
 194 SYSCALL4(task_create, id_t, const char *, const start_state_t *, id_t *);
 195 SYSCALL1(task_exit, int);
 196 SYSCALL0(task_yield);
 197
 198 /**
 199  * ELF related system calls.
 200  */
 201 SYSCALL2(elf_hwcap, id_t, uint32_t *);