src/lib/user/syscall.c

   1 #include <syscall.h>
   2 #include "../syscall-nr.h"
   3
   4 /* Invokes syscall NUMBER, passing no arguments, and returns the
   5    return value as an `int'. */
   6 #define syscall0(NUMBER)                                        \
   7         ({                                                      \
   8           int retval;                                           \
   9           asm volatile                                          \
  10             ("pushl %[number]; int $0x30; addl $4, %%esp"       \
  11                : "=a" (retval)                                  \
  12                : [number] "i" (NUMBER)                          \
  13                : "memory");                                     \
  14           retval;                                               \
  15         })
  16
  17 /* Invokes syscall NUMBER, passing argument ARG0, and returns the
  18    return value as an `int'. */
  19 #define syscall1(NUMBER, ARG0)                                           \
  20         ({                                                               \
  21           int retval;                                                    \
  22           asm volatile                                                   \
  23             ("pushl %[arg0]; pushl %[number]; int $0x30; addl $8, %%esp" \
  24                : "=a" (retval)                                           \
  25                : [number] "i" (NUMBER),                                  \
  26                  [arg0] "g" (ARG0)                                       \
  27                : "memory");                                              \
  28           retval;                                                        \
  29         })
  30
  31 /* Invokes syscall NUMBER, passing arguments ARG0 and ARG1, and
  32    returns the return value as an `int'. */
  33 #define syscall2(NUMBER, ARG0, ARG1)                            \
  34         ({                                                      \
  35           int retval;                                           \
  36           asm volatile                                          \
  37             ("pushl %[arg1]; pushl %[arg0]; "                   \
  38              "pushl %[number]; int $0x30; addl $12, %%esp"      \
  39                : "=a" (retval)                                  \
  40                : [number] "i" (NUMBER),                         \
  41                  [arg0] "g" (ARG0),                             \
  42                  [arg1] "g" (ARG1)                              \
  43                : "memory");                                     \
  44           retval;                                               \
  45         })
  46
  47 /* Invokes syscall NUMBER, passing arguments ARG0, ARG1, and
  48    ARG2, and returns the return value as an `int'. */
  49 #define syscall3(NUMBER, ARG0, ARG1, ARG2)                      \
  50         ({                                                      \
  51           int retval;                                           \
  52           asm volatile                                          \
  53             ("pushl %[arg2]; pushl %[arg1]; pushl %[arg0]; "    \
  54              "pushl %[number]; int $0x30; addl $16, %%esp"      \
  55                : "=a" (retval)                                  \
  56                : [number] "i" (NUMBER),                         \
  57                  [arg0] "g" (ARG0),                             \
  58                  [arg1] "g" (ARG1),                             \
  59                  [arg2] "g" (ARG2)                              \
  60                : "memory");                                     \
  61           retval;                                               \
  62         })
  63
  64 void
  65 halt (void)
  66 {
  67   syscall0 (SYS_HALT);
  68   NOT_REACHED ();
  69 }
  70
  71 void
  72 exit (int status)
  73 {
  74   syscall1 (SYS_EXIT, status);
  75   NOT_REACHED ();
  76 }
  77
  78 pid_t
  79 exec (const char *file)
  80 {
  81   return (pid_t) syscall1 (SYS_EXEC, file);
  82 }
  83
  84 int
  85 wait (pid_t pid)
  86 {
  87   return syscall1 (SYS_WAIT, pid);
  88 }
  89
  90 bool
  91 create (const char *file, unsigned initial_size)
  92 {
  93   return syscall2 (SYS_CREATE, file, initial_size);
  94 }
  95
  96 bool
  97 remove (const char *file)
  98 {
  99   return syscall1 (SYS_REMOVE, file);
 100 }
 101
 102 int
 103 open (const char *file)
 104 {
 105   return syscall1 (SYS_OPEN, file);
 106 }
 107
 108 int
 109 filesize (int fd)
 110 {
 111   return syscall1 (SYS_FILESIZE, fd);
 112 }
 113
 114 int
 115 read (int fd, void *buffer, unsigned size)
 116 {
 117   return syscall3 (SYS_READ, fd, buffer, size);
 118 }
 119
 120 int
 121 write (int fd, const void *buffer, unsigned size)
 122 {
 123   return syscall3 (SYS_WRITE, fd, buffer, size);
 124 }
 125
 126 void
 127 seek (int fd, unsigned position)
 128 {
 129   syscall2 (SYS_SEEK, fd, position);
 130 }
 131
 132 unsigned
 133 tell (int fd)
 134 {
 135   return syscall1 (SYS_TELL, fd);
 136 }
 137
 138 void
 139 close (int fd)
 140 {
 141   syscall1 (SYS_CLOSE, fd);
 142 }
 143
 144 mapid_t
 145 mmap (int fd, void *addr)
 146 {
 147   return syscall2 (SYS_MMAP, fd, addr);
 148 }
 149
 150 void
 151 munmap (mapid_t mapid)
 152 {
 153   syscall1 (SYS_MUNMAP, mapid);
 154 }
 155
 156 bool
 157 chdir (const char *dir)
 158 {
 159   return syscall1 (SYS_CHDIR, dir);
 160 }
 161
 162 bool
 163 mkdir (const char *dir)
 164 {
 165   return syscall1 (SYS_MKDIR, dir);
 166 }
 167
 168 void
 169 lsdir (void)
 170 {
 171   syscall0 (SYS_LSDIR);
 172 }
 173