X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?p=pintos-anon;a=blobdiff_plain;f=src%2Flib%2Fuser%2Fsyscall.c;h=c8385bc3364b1eabc57e68bae885fe458537b42a;hp=aaeb109314775c49f626e3bf9b27445a96d93416;hb=ea904493370d2a752855cc93aad1e27b009dd917;hpb=fcb5d5ae90ae9d5319a3e4b7aed2c751e1dfaadf

diff --git a/src/lib/user/syscall.c b/src/lib/user/syscall.c
index aaeb109..c8385bc 100644
--- a/src/lib/user/syscall.c
+++ b/src/lib/user/syscall.c
@@ -3,45 +3,45 @@
 
 /* Invokes syscall NUMBER, passing no arguments, and returns the
    return value as an `int'. */
-#define syscall0(NUMBER)                                \
-        ({                                              \
-          int retval;                                   \
-          asm volatile                                  \
-            ("push %[number]; int 0x30; add %%esp, 4"   \
-               : "=a" (retval)                          \
-               : [number] "i" (NUMBER)                  \
-               : "memory");                             \
-          retval;                                       \
+#define syscall0(NUMBER)                                        \
+        ({                                                      \
+          int retval;                                           \
+          asm volatile                                          \
+            ("pushl %[number]; int $0x30; addl $4, %%esp"       \
+               : "=a" (retval)                                  \
+               : [number] "i" (NUMBER)                          \
+               : "memory");                                     \
+          retval;                                               \
         })
 
 /* Invokes syscall NUMBER, passing argument ARG0, and returns the
    return value as an `int'. */
-#define syscall1(NUMBER, ARG0)                                          \
-        ({                                                              \
-          int retval;                                                   \
-          asm volatile                                                  \
-            ("push %[arg0]; push %[number]; int 0x30; add %%esp, 8"     \
-               : "=a" (retval)                                          \
-               : [number] "i" (NUMBER),                                 \
-                 [arg0] "g" (ARG0)                                      \
-               : "memory");                                             \
-          retval;                                                       \
+#define syscall1(NUMBER, ARG0)                                           \
+        ({                                                               \
+          int retval;                                                    \
+          asm volatile                                                   \
+            ("pushl %[arg0]; pushl %[number]; int $0x30; addl $8, %%esp" \
+               : "=a" (retval)                                           \
+               : [number] "i" (NUMBER),                                  \
+                 [arg0] "g" (ARG0)                                       \
+               : "memory");                                              \
+          retval;                                                        \
         })
 
 /* Invokes syscall NUMBER, passing arguments ARG0 and ARG1, and
    returns the return value as an `int'. */
-#define syscall2(NUMBER, ARG0, ARG1)                    \
-        ({                                              \
-          int retval;                                   \
-          asm volatile                                  \
-            ("push %[arg1]; push %[arg0]; "             \
-             "push %[number]; int 0x30; add %%esp, 12"  \
-               : "=a" (retval)                          \
-               : [number] "i" (NUMBER),                 \
-                 [arg0] "g" (ARG0),                     \
-                 [arg1] "g" (ARG1)                      \
-               : "memory");                             \
-          retval;                                       \
+#define syscall2(NUMBER, ARG0, ARG1)                            \
+        ({                                                      \
+          int retval;                                           \
+          asm volatile                                          \
+            ("pushl %[arg1]; pushl %[arg0]; "                   \
+             "pushl %[number]; int $0x30; addl $12, %%esp"      \
+               : "=a" (retval)                                  \
+               : [number] "i" (NUMBER),                         \
+                 [arg0] "r" (ARG0),                             \
+                 [arg1] "r" (ARG1)                              \
+               : "memory");                                     \
+          retval;                                               \
         })
 
 /* Invokes syscall NUMBER, passing arguments ARG0, ARG1, and
@@ -50,13 +50,13 @@
         ({                                                      \
           int retval;                                           \
           asm volatile                                          \
-            ("push %[arg2]; push %[arg1]; push %[arg0]; "       \
-             "push %[number]; int 0x30; add %%esp, 16"          \
+            ("pushl %[arg2]; pushl %[arg1]; pushl %[arg0]; "    \
+             "pushl %[number]; int $0x30; addl $16, %%esp"      \
                : "=a" (retval)                                  \
                : [number] "i" (NUMBER),                         \
-                 [arg0] "g" (ARG0),                             \
-                 [arg1] "g" (ARG1),                             \
-                 [arg2] "g" (ARG2)                              \
+                 [arg0] "r" (ARG0),                             \
+                 [arg1] "r" (ARG1),                             \
+                 [arg2] "r" (ARG2)                              \
                : "memory");                                     \
           retval;                                               \
         })
@@ -64,110 +64,121 @@
 void
 halt (void) 
 {
-  syscall0 (SYS_halt);
+  syscall0 (SYS_HALT);
   NOT_REACHED ();
 }
 
 void
 exit (int status)
 {
-  syscall1 (SYS_exit, status);
+  syscall1 (SYS_EXIT, status);
   NOT_REACHED ();
 }
 
 pid_t
 exec (const char *file)
 {
-  return (pid_t) syscall1 (SYS_exec, file);
+  return (pid_t) syscall1 (SYS_EXEC, file);
 }
 
 int
-join (pid_t pid)
+wait (pid_t pid)
 {
-  return syscall1 (SYS_join, pid);
+  return syscall1 (SYS_WAIT, pid);
 }
 
 bool
 create (const char *file, unsigned initial_size)
 {
-  return syscall2 (SYS_create, file, initial_size);
+  return syscall2 (SYS_CREATE, file, initial_size);
 }
 
 bool
 remove (const char *file)
 {
-  return syscall1 (SYS_remove, file);
+  return syscall1 (SYS_REMOVE, file);
 }
 
 int
 open (const char *file)
 {
-  return syscall1 (SYS_open, file);
+  return syscall1 (SYS_OPEN, file);
 }
 
 int
 filesize (int fd) 
 {
-  return syscall1 (SYS_filesize, fd);
+  return syscall1 (SYS_FILESIZE, fd);
 }
 
 int
 read (int fd, void *buffer, unsigned size)
 {
-  return syscall3 (SYS_read, fd, buffer, size);
+  return syscall3 (SYS_READ, fd, buffer, size);
 }
 
 int
 write (int fd, const void *buffer, unsigned size)
 {
-  return syscall3 (SYS_write, fd, buffer, size);
+  return syscall3 (SYS_WRITE, fd, buffer, size);
 }
 
 void
 seek (int fd, unsigned position) 
 {
-  syscall2 (SYS_seek, fd, position);
+  syscall2 (SYS_SEEK, fd, position);
 }
 
 unsigned
 tell (int fd) 
 {
-  return syscall1 (SYS_tell, fd);
+  return syscall1 (SYS_TELL, fd);
 }
 
 void
 close (int fd)
 {
-  syscall1 (SYS_close, fd);
+  syscall1 (SYS_CLOSE, fd);
 }
 
-bool
-mmap (int fd, void *addr, unsigned length)
+mapid_t
+mmap (int fd, void *addr)
 {
-  return syscall3 (SYS_mmap, fd, addr, length);
+  return syscall2 (SYS_MMAP, fd, addr);
 }
 
-bool
-munmap (void *addr, unsigned length)
+void
+munmap (mapid_t mapid)
 {
-  return syscall2 (SYS_munmap, addr, length);
+  syscall1 (SYS_MUNMAP, mapid);
 }
 
 bool
 chdir (const char *dir)
 {
-  return syscall1 (SYS_chdir, dir);
+  return syscall1 (SYS_CHDIR, dir);
 }
 
 bool
 mkdir (const char *dir)
 {
-  return syscall1 (SYS_mkdir, dir);
+  return syscall1 (SYS_MKDIR, dir);
 }
 
-void
-lsdir (void)
+bool
+readdir (int fd, char name[READDIR_MAX_LEN + 1]) 
+{
+  return syscall2 (SYS_READDIR, fd, name);
+}
+
+bool
+isdir (int fd) 
 {
-  syscall0 (SYS_lsdir);
+  return syscall1 (SYS_ISDIR, fd);
 }
 
+int
+inumber (int fd) 
+{
+  return syscall1 (SYS_INUMBER, fd);
+}