Automatic date update in version.in

[deliverable/binutils-gdb.git] / sim / common / syscall.c

diff --git a/sim/common/syscall.c b/sim/common/syscall.c
index 4bbb0c52e05fbdf86a807fe1ca597b3eea92071f..18128c74930c7a3ad9256fedb33ce0ea982ea60e 100644 (file)
--- a/sim/common/syscall.c
+++ b/sim/common/syscall.c
@@ -1,12 +1,12 @@
 /* Remote target system call support.
 /* Remote target system call support.

-   Copyright 1997 Free Software Foundation, Inc.
+   Copyright 1997-2020 Free Software Foundation, Inc.

    Contributed by Cygnus Solutions.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    Contributed by Cygnus Solutions.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -15,8 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with GAS; see the file COPYING.  If not, write to the Free Software
-   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 /* This interface isn't intended to be specific to any particular kind
    of remote (hardware, simulator, whatever).  As such, support for it
 
 /* This interface isn't intended to be specific to any particular kind
    of remote (hardware, simulator, whatever).  As such, support for it


@@ -28,44 +27,57 @@
 #include "config.h"
 #endif
 #include "ansidecl.h"
 #include "config.h"
 #endif
 #include "ansidecl.h"

-#ifdef ANSI_PROTOTYPES
+#include "libiberty.h"

 #include <stdarg.h>
 #include <stdarg.h>

-#else
-#include <varargs.h>
-#endif

 #include <stdio.h>
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 #include <stdio.h>
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif

+#ifdef HAVE_STRING_H
+#include <string.h>
+#elif defined (HAVE_STRINGS_H)
+#include <strings.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif

 #include <errno.h>
 #include <fcntl.h>
 #include <time.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <time.h>

-#include "callback.h"
-#include "remote-sim.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "gdb/callback.h"

 #include "targ-vals.h"
 
 #include "targ-vals.h"
 

-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
+#ifndef ENOSYS
+#define ENOSYS EINVAL
+#endif
+#ifndef ENAMETOOLONG
+#define ENAMETOOLONG EINVAL

 #endif
 #endif

-
-/* When doing file read/writes, do this many bytes at a time.  */
-#define FILE_XFR_SIZE 4096

 
 /* Maximum length of a path name.  */
 #ifndef MAX_PATH_LEN
 #define MAX_PATH_LEN 1024
 #endif
 
 
 /* Maximum length of a path name.  */
 #ifndef MAX_PATH_LEN
 #define MAX_PATH_LEN 1024
 #endif
 

-/* Utility of cb_syscall to fetch a path name from the target.
-   The result is 0 for success or a target errno value.  */
+/* When doing file read/writes, do this many bytes at a time.  */
+#define FILE_XFR_SIZE 4096

 
 

-static int
-get_path (cb, sc, buf, buflen, addr)
-     host_callback *cb;
-     CB_SYSCALL *sc;
-     char *buf;
-     int buflen;
-     long addr;
+/* FIXME: for now, need to consider target word size.  */
+#define TWORD long
+#define TADDR unsigned long
+
+/* Path to be prepended to syscalls with absolute paths, and to be
+   chdir:ed at startup, if not empty.  */
+char *simulator_sysroot = "";
+
+/* Utility of cb_syscall to fetch a path name or other string from the target.
+   The result is 0 for success or a host errno value.  */
+
+int
+cb_get_string (host_callback *cb, CB_SYSCALL *sc, char *buf, int buflen,
+              TADDR addr)

 {
   char *p, *pend;
 
 {
   char *p, *pend;
 


@@ -74,28 +86,65 @@ get_path (cb, sc, buf, buflen, addr)
       /* No, it isn't expected that this would cause one transaction with
         the remote target for each byte.  The target could send the
         path name along with the syscall request, and cache the file
       /* No, it isn't expected that this would cause one transaction with
         the remote target for each byte.  The target could send the
         path name along with the syscall request, and cache the file

-        name somewhere.  */
+        name somewhere (or otherwise tweak this as desired).  */

       unsigned int count = (*sc->read_mem) (cb, sc, addr, p, 1);
       unsigned int count = (*sc->read_mem) (cb, sc, addr, p, 1);

-                                   
+

       if (count != 1)
       if (count != 1)

-       return TARGET_EINVAL;
+       return EINVAL;

       if (*p == 0)
        break;
     }
   if (p == pend)
       if (*p == 0)
        break;
     }
   if (p == pend)

-    return TARGET_ENAMETOOLONG;
+    return ENAMETOOLONG;

   return 0;
 }
 
   return 0;
 }
 

+/* Utility of cb_syscall to fetch a path name.
+   The buffer is malloc'd and the address is stored in BUFP.
+   The result is that of get_string, but prepended with
+   simulator_sysroot if the string starts with '/'.
+   If an error occurs, no buffer is left malloc'd.  */
+
+static int
+get_path (host_callback *cb, CB_SYSCALL *sc, TADDR addr, char **bufp)
+{
+  char *buf = xmalloc (MAX_PATH_LEN);
+  int result;
+  int sysroot_len = strlen (simulator_sysroot);
+
+  result = cb_get_string (cb, sc, buf, MAX_PATH_LEN - sysroot_len, addr);
+  if (result == 0)
+    {
+      /* Prepend absolute paths with simulator_sysroot.  Relative paths
+        are supposed to be relative to a chdir within that path, but at
+        this point unknown where.  */
+      if (simulator_sysroot[0] != '\0' && *buf == '/')
+       {
+         /* Considering expected rareness of syscalls with absolute
+            file paths (compared to relative file paths and insn
+            execution), it does not seem worthwhile to rearrange things
+            to get rid of the string moves here; we'd need at least an
+            extra call to check the initial '/' in the path.  */
+         memmove (buf + sysroot_len, buf, sysroot_len);
+         memcpy (buf, simulator_sysroot, sysroot_len);
+       }
+
+      *bufp = buf;
+    }
+  else
+    free (buf);
+  return result;
+}
+

 /* Perform a system call on behalf of the target.  */
 
 CB_RC
 /* Perform a system call on behalf of the target.  */
 
 CB_RC

-cb_syscall (cb, sc)
-     host_callback *cb;
-     CB_SYSCALL *sc;
+cb_syscall (host_callback *cb, CB_SYSCALL *sc)

 {
 {

-  /* ??? Need to consider target word size.  */
-  long result = 0, errcode = 0;
+  TWORD result = 0, errcode = 0;
+
+  if (sc->magic != CB_SYSCALL_MAGIC)
+    abort ();

 
   switch (cb_target_to_host_syscall (cb, sc->func))
     {
 
   switch (cb_target_to_host_syscall (cb, sc->func))
     {


@@ -129,11 +178,11 @@ cb_syscall (cb, sc)
     case CB_SYS_argv :
       {
        /* Pointer to target's buffer.  */
     case CB_SYS_argv :
       {
        /* Pointer to target's buffer.  */

-       SIM_ADDR tbuf = sc->arg1;
+       TADDR tbuf = sc->arg1;

        /* Buffer size.  */
        int bufsize = sc->arg2;
        /* Q is the target address of where all the strings go.  */
        /* Buffer size.  */
        int bufsize = sc->arg2;
        /* Q is the target address of where all the strings go.  */

-       SIM_ADDR q;
+       TADDR q;

        int word_size = cb->word_size;
        int i,argc,envc,len;
        const char **argv = cb->init_argv;
        int word_size = cb->word_size;
        int i,argc,envc,len;
        const char **argv = cb->init_argv;


@@ -149,7 +198,7 @@ cb_syscall (cb, sc)
                if (written != len)
                  {
                    result = -1;
                if (written != len)
                  {
                    result = -1;

-                   errcode = TARGET_EINVAL;
+                   errcode = EINVAL;

                    goto FinishSyscall;
                  }
                tbuf = len + 1;
                    goto FinishSyscall;
                  }
                tbuf = len + 1;


@@ -158,7 +207,7 @@ cb_syscall (cb, sc)
        if ((*sc->write_mem) (cb, sc, tbuf, "", 1) != 1)
          {
            result = -1;
        if ((*sc->write_mem) (cb, sc, tbuf, "", 1) != 1)
          {
            result = -1;

-           errcode = TARGET_EINVAL;
+           errcode = EINVAL;

            goto FinishSyscall;
          }
        tbuf++;
            goto FinishSyscall;
          }
        tbuf++;


@@ -172,7 +221,7 @@ cb_syscall (cb, sc)
                if (written != len)
                  {
                    result = -1;
                if (written != len)
                  {
                    result = -1;

-                   errcode = TARGET_EINVAL;
+                   errcode = EINVAL;

                    goto FinishSyscall;
                  }
                tbuf = len + 1;
                    goto FinishSyscall;
                  }
                tbuf = len + 1;


@@ -181,7 +230,7 @@ cb_syscall (cb, sc)
        if ((*sc->write_mem) (cb, sc, tbuf, "", 1) != 1)
          {
            result = -1;
        if ((*sc->write_mem) (cb, sc, tbuf, "", 1) != 1)
          {
            result = -1;

-           errcode = TARGET_EINVAL;
+           errcode = EINVAL;

            goto FinishSyscall;
          }
        result = argc;
            goto FinishSyscall;
          }
        result = argc;


@@ -191,27 +240,30 @@ cb_syscall (cb, sc)
 #endif /* wip */
 
     case CB_SYS_exit :
 #endif /* wip */
 
     case CB_SYS_exit :

-      /* Caller must catch and handle.  */
+      /* Caller must catch and handle; see sim_syscall as an example.  */

       break;
 
     case CB_SYS_open :
       {
       break;
 
     case CB_SYS_open :
       {

-       char path[MAX_PATH_LEN];
-       int errcode;
+       char *path;

 
 

-       errcode = get_path (cb, sc, path, MAX_PATH_LEN, sc->arg1);
+       errcode = get_path (cb, sc, sc->arg1, &path);

        if (errcode != 0)
          {
            result = -1;
        if (errcode != 0)
          {
            result = -1;

-           errcode = errcode;

            goto FinishSyscall;
          }
        result = (*cb->open) (cb, path, sc->arg2 /*, sc->arg3*/);
            goto FinishSyscall;
          }
        result = (*cb->open) (cb, path, sc->arg2 /*, sc->arg3*/);

+       free (path);
+       if (result < 0)
+         goto ErrorFinish;

       }
       break;
 
     case CB_SYS_close :
       result = (*cb->close) (cb, sc->arg1);
       }
       break;
 
     case CB_SYS_close :
       result = (*cb->close) (cb, sc->arg1);

+      if (result < 0)
+       goto ErrorFinish;

       break;
 
     case CB_SYS_read :
       break;
 
     case CB_SYS_read :


@@ -222,27 +274,38 @@ cb_syscall (cb, sc)
           malloc'ing/free'ing the space.  Maybe later.  */
        char buf[FILE_XFR_SIZE];
        int fd = sc->arg1;
           malloc'ing/free'ing the space.  Maybe later.  */
        char buf[FILE_XFR_SIZE];
        int fd = sc->arg1;

-       SIM_ADDR addr = sc->arg2;
+       TADDR addr = sc->arg2;

        size_t count = sc->arg3;
        size_t bytes_read = 0;
        int bytes_written;
 
        while (count > 0)
          {
        size_t count = sc->arg3;
        size_t bytes_read = 0;
        int bytes_written;
 
        while (count > 0)
          {

-           result = (int) (*cb->read) (cb, fd, buf,
-                                       count < FILE_XFR_SIZE ? count : FILE_XFR_SIZE);
+           if (cb_is_stdin (cb, fd))
+             result = (int) (*cb->read_stdin) (cb, buf,
+                                               (count < FILE_XFR_SIZE
+                                                ? count : FILE_XFR_SIZE));
+           else
+             result = (int) (*cb->read) (cb, fd, buf,
+                                         (count < FILE_XFR_SIZE
+                                          ? count : FILE_XFR_SIZE));

            if (result == -1)
            if (result == -1)

-             goto FinishSyscall;
+             goto ErrorFinish;
+           if (result == 0)    /* EOF */
+             break;

            bytes_written = (*sc->write_mem) (cb, sc, addr, buf, result);
            if (bytes_written != result)
              {
                result = -1;
            bytes_written = (*sc->write_mem) (cb, sc, addr, buf, result);
            if (bytes_written != result)
              {
                result = -1;

-               errcode = TARGET_EINVAL;
+               errcode = EINVAL;

                goto FinishSyscall;
              }
            bytes_read += result;
            count -= result;
            addr += result;
                goto FinishSyscall;
              }
            bytes_read += result;
            count -= result;
            addr += result;

+           /* If this is a short read, don't go back for more */
+           if (result != FILE_XFR_SIZE)
+             break;

          }
        result = bytes_read;
       }
          }
        result = bytes_read;
       }


@@ -256,7 +319,7 @@ cb_syscall (cb, sc)
           malloc'ing/free'ing the space.  Maybe later.  */
        char buf[FILE_XFR_SIZE];
        int fd = sc->arg1;
           malloc'ing/free'ing the space.  Maybe later.  */
        char buf[FILE_XFR_SIZE];
        int fd = sc->arg1;

-       SIM_ADDR addr = sc->arg2;
+       TADDR addr = sc->arg2;

        size_t count = sc->arg3;
        int bytes_read;
        size_t bytes_written = 0;
        size_t count = sc->arg3;
        int bytes_read;
        size_t bytes_written = 0;


@@ -268,15 +331,23 @@ cb_syscall (cb, sc)
            if (bytes_read != bytes_to_read)
              {
                result = -1;
            if (bytes_read != bytes_to_read)
              {
                result = -1;

-               errcode = TARGET_EINVAL;
+               errcode = EINVAL;

                goto FinishSyscall;
              }
                goto FinishSyscall;
              }

-           if (fd == 1)
-             result = (int) (*cb->write_stdout) (cb, buf, bytes_read);
+           if (cb_is_stdout (cb, fd))
+             {
+               result = (int) (*cb->write_stdout) (cb, buf, bytes_read);
+               (*cb->flush_stdout) (cb);
+             }
+           else if (cb_is_stderr (cb, fd))
+             {
+               result = (int) (*cb->write_stderr) (cb, buf, bytes_read);
+               (*cb->flush_stderr) (cb);
+             }

            else
              result = (int) (*cb->write) (cb, fd, buf, bytes_read);
            if (result == -1)
            else
              result = (int) (*cb->write) (cb, fd, buf, bytes_read);
            if (result == -1)

-             goto FinishSyscall;
+             goto ErrorFinish;

            bytes_written += result;
            count -= result;
            addr += result;
            bytes_written += result;
            count -= result;
            addr += result;


@@ -285,22 +356,267 @@ cb_syscall (cb, sc)
       }
       break;
 
       }
       break;
 

+    case CB_SYS_lseek :
+      {
+       int fd = sc->arg1;
+       unsigned long offset = sc->arg2;
+       int whence = sc->arg3;
+
+       result = (*cb->lseek) (cb, fd, offset, whence);
+       if (result < 0)
+         goto ErrorFinish;
+      }
+      break;
+
+    case CB_SYS_unlink :
+      {
+       char *path;
+
+       errcode = get_path (cb, sc, sc->arg1, &path);
+       if (errcode != 0)
+         {
+           result = -1;
+           goto FinishSyscall;
+         }
+       result = (*cb->unlink) (cb, path);
+       free (path);
+       if (result < 0)
+         goto ErrorFinish;
+      }
+      break;
+
+    case CB_SYS_truncate :
+      {
+       char *path;
+       long len = sc->arg2;
+
+       errcode = get_path (cb, sc, sc->arg1, &path);
+       if (errcode != 0)
+         {
+           result = -1;
+           errcode = EFAULT;
+           goto FinishSyscall;
+         }
+       result = (*cb->truncate) (cb, path, len);
+       free (path);
+       if (result < 0)
+         goto ErrorFinish;
+      }
+      break;
+
+    case CB_SYS_ftruncate :
+      {
+       int fd = sc->arg1;
+       long len = sc->arg2;
+
+       result = (*cb->ftruncate) (cb, fd, len);
+       if (result < 0)
+         goto ErrorFinish;
+      }
+      break;
+
+    case CB_SYS_rename :
+      {
+       char *path1, *path2;
+
+       errcode = get_path (cb, sc, sc->arg1, &path1);
+       if (errcode != 0)
+         {
+           result = -1;
+           errcode = EFAULT;
+           goto FinishSyscall;
+         }
+       errcode = get_path (cb, sc, sc->arg2, &path2);
+       if (errcode != 0)
+         {
+           result = -1;
+           errcode = EFAULT;
+           free (path1);
+           goto FinishSyscall;
+         }
+       result = (*cb->rename) (cb, path1, path2);
+       free (path1);
+       free (path2);
+       if (result < 0)
+         goto ErrorFinish;
+      }
+      break;
+
+    case CB_SYS_stat :
+      {
+       char *path,*buf;
+       int buflen;
+       struct stat statbuf;
+       TADDR addr = sc->arg2;
+
+       errcode = get_path (cb, sc, sc->arg1, &path);
+       if (errcode != 0)
+         {
+           result = -1;
+           goto FinishSyscall;
+         }
+       result = (*cb->to_stat) (cb, path, &statbuf);
+       free (path);
+       if (result < 0)
+         goto ErrorFinish;
+       buflen = cb_host_to_target_stat (cb, NULL, NULL);
+       buf = xmalloc (buflen);
+       if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
+         {
+           /* The translation failed.  This is due to an internal
+              host program error, not the target's fault.  */
+           free (buf);
+           errcode = ENOSYS;
+           result = -1;
+           goto FinishSyscall;
+         }
+       if ((*sc->write_mem) (cb, sc, addr, buf, buflen) != buflen)
+         {
+           free (buf);
+           errcode = EINVAL;
+           result = -1;
+           goto FinishSyscall;
+         }
+       free (buf);
+      }
+      break;
+
+    case CB_SYS_fstat :
+      {
+       char *buf;
+       int buflen;
+       struct stat statbuf;
+       TADDR addr = sc->arg2;
+
+       result = (*cb->to_fstat) (cb, sc->arg1, &statbuf);
+       if (result < 0)
+         goto ErrorFinish;
+       buflen = cb_host_to_target_stat (cb, NULL, NULL);
+       buf = xmalloc (buflen);
+       if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
+         {
+           /* The translation failed.  This is due to an internal
+              host program error, not the target's fault.  */
+           free (buf);
+           errcode = ENOSYS;
+           result = -1;
+           goto FinishSyscall;
+         }
+       if ((*sc->write_mem) (cb, sc, addr, buf, buflen) != buflen)
+         {
+           free (buf);
+           errcode = EINVAL;
+           result = -1;
+           goto FinishSyscall;
+         }
+       free (buf);
+      }
+      break;
+
+    case CB_SYS_lstat :
+      {
+       char *path, *buf;
+       int buflen;
+       struct stat statbuf;
+       TADDR addr = sc->arg2;
+
+       errcode = get_path (cb, sc, sc->arg1, &path);
+       if (errcode != 0)
+         {
+           result = -1;
+           goto FinishSyscall;
+         }
+       result = (*cb->to_lstat) (cb, path, &statbuf);
+       free (path);
+       if (result < 0)
+         goto ErrorFinish;
+
+       buflen = cb_host_to_target_stat (cb, NULL, NULL);
+       buf = xmalloc (buflen);
+       if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
+         {
+           /* The translation failed.  This is due to an internal
+              host program error, not the target's fault.
+              Unfortunately, it's hard to test this case, so there's no
+              test-case for this execution path.  */
+           free (buf);
+           errcode = ENOSYS;
+           result = -1;
+           goto FinishSyscall;
+         }
+
+       if ((*sc->write_mem) (cb, sc, addr, buf, buflen) != buflen)
+         {
+           free (buf);
+           errcode = EINVAL;
+           result = -1;
+           goto FinishSyscall;
+         }
+
+       free (buf);
+      }
+      break;
+
+    case CB_SYS_pipe :
+      {
+       int p[2];
+       char *target_p = xcalloc (1, cb->target_sizeof_int * 2);
+
+       result = (*cb->pipe) (cb, p);
+       if (result != 0)
+         goto ErrorFinish;
+
+       cb_store_target_endian (cb, target_p, cb->target_sizeof_int, p[0]);
+       cb_store_target_endian (cb, target_p + cb->target_sizeof_int,
+                               cb->target_sizeof_int, p[1]);
+       if ((*sc->write_mem) (cb, sc, sc->arg1, target_p,
+                             cb->target_sizeof_int * 2)
+           != cb->target_sizeof_int * 2)
+         {
+           /* Close the pipe fd:s.  */
+           (*cb->close) (cb, p[0]);
+           (*cb->close) (cb, p[1]);
+           errcode = EFAULT;
+           result = -1;
+         }
+
+       free (target_p);
+      }
+      break;
+
+    case CB_SYS_time :
+      {
+       /* FIXME: May wish to change CB_SYS_time to something else.
+          We might also want gettimeofday or times, but if system calls
+          can be built on others, we can keep the number we have to support
+          here down.  */
+       time_t t = (*cb->time) (cb, (time_t *) 0);
+       result = t;
+       /* It is up to target code to process the argument to time().  */
+      }
+      break;
+
+    case CB_SYS_chdir :
+    case CB_SYS_chmod :
+    case CB_SYS_utime :
+      /* fall through for now */
+

     default :
       result = -1;
     default :
       result = -1;

-#ifdef TARGET_ENOSYS
-      errcode = TARGET_ENOSYS;
-#else
-      errcode = TARGET_EINVAL;
-#endif
+      errcode = ENOSYS;

       break;
     }
 
  FinishSyscall:
   sc->result = result;
   if (errcode == 0)
       break;
     }
 
  FinishSyscall:
   sc->result = result;
   if (errcode == 0)

-    sc->errcode = (*cb->get_errno) (cb);
+    sc->errcode = 0;

   else
   else

-    sc->errcode = errcode;
+    sc->errcode = cb_host_to_target_errno (cb, errcode);
+  return CB_RC_OK;

 
 

+ ErrorFinish:
+  sc->result = result;
+  sc->errcode = (*cb->get_errno) (cb);

   return CB_RC_OK;
 }
   return CB_RC_OK;
 }