sim/common/syscall.c

   1 /* Remote target system call support.
   2    Copyright 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Solutions.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to the Free Software
  19    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* This interface isn't intended to be specific to any particular kind
  22    of remote (hardware, simulator, whatever).  As such, support for it
  23    (e.g. sim/common/callback.c) should *not* live in the simulator source
  24    tree, nor should it live in the gdb source tree.  K&R C must be
  25    supported.  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30 #include "ansidecl.h"
  31 #include "libiberty.h"
  32 #ifdef ANSI_PROTOTYPES
  33 #include <stdarg.h>
  34 #else
  35 #include <varargs.h>
  36 #endif
  37 #include <stdio.h>
  38 #ifdef HAVE_STDLIB_H
  39 #include <stdlib.h>
  40 #endif
  41 #ifdef HAVE_UNISTD_H
  42 #include <unistd.h>
  43 #endif
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #include <time.h>
  47 #include <sys/types.h>
  48 #include <sys/stat.h>
  49 #include "callback.h"
  50 #include "targ-vals.h"
  51
  52 #ifndef ENOSYS
  53 #define ENOSYS EINVAL
  54 #endif
  55 #ifndef ENAMETOOLONG
  56 #define ENAMETOOLONG EINVAL
  57 #endif
  58
  59 /* Maximum length of a path name.  */
  60 #ifndef MAX_PATH_LEN
  61 #define MAX_PATH_LEN 1024
  62 #endif
  63
  64 /* When doing file read/writes, do this many bytes at a time.  */
  65 #define FILE_XFR_SIZE 4096
  66
  67 /* FIXME: for now, need to consider target word size.  */
  68 #define TWORD long
  69 #define TADDR unsigned long
  70
  71 /* Utility of cb_syscall to fetch a path name or other string from the target.
  72    The result is 0 for success or a host errno value.  */
  73
  74 static int
  75 get_string (cb, sc, buf, buflen, addr)
  76      host_callback *cb;
  77      CB_SYSCALL *sc;
  78      char *buf;
  79      int buflen;
  80      TADDR addr;
  81 {
  82   char *p, *pend;
  83
  84   for (p = buf, pend = buf + buflen; p < pend; ++p, ++addr)
  85     {
  86       /* No, it isn't expected that this would cause one transaction with
  87          the remote target for each byte.  The target could send the
  88          path name along with the syscall request, and cache the file
  89          name somewhere (or otherwise tweak this as desired).  */
  90       unsigned int count = (*sc->read_mem) (cb, sc, addr, p, 1);
  91
  92       if (count != 1)
  93         return EINVAL;
  94       if (*p == 0)
  95         break;
  96     }
  97   if (p == pend)
  98     return ENAMETOOLONG;
  99   return 0;
 100 }
 101
 102 /* Utility of cb_syscall to fetch a path name.
 103    The buffer is malloc'd and the address is stored in BUFP.
 104    The result is that of get_string.
 105    If an error occurs, no buffer is left malloc'd.  */
 106
 107 static int
 108 get_path (cb, sc, addr, bufp)
 109      host_callback *cb;
 110      CB_SYSCALL *sc;
 111      TADDR addr;
 112      char **bufp;
 113 {
 114   char *buf = xmalloc (MAX_PATH_LEN);
 115   int result;
 116
 117   result = get_string (cb, sc, buf, MAX_PATH_LEN, addr);
 118   if (result == 0)
 119     *bufp = buf;
 120   else
 121     free (buf);
 122   return result;
 123 }
 124
 125 /* Perform a system call on behalf of the target.  */
 126
 127 CB_RC
 128 cb_syscall (cb, sc)
 129      host_callback *cb;
 130      CB_SYSCALL *sc;
 131 {
 132   TWORD result = 0, errcode = 0;
 133
 134   if (sc->magic != CB_SYSCALL_MAGIC)
 135     abort ();
 136
 137   switch (cb_target_to_host_syscall (cb, sc->func))
 138     {
 139 #if 0 /* FIXME: wip */
 140     case CB_SYS_argvlen :
 141       {
 142         /* Compute how much space is required to store the argv,envp
 143            strings so that the program can allocate the space and then
 144            call SYS_argv to fetch the values.  */
 145         int addr_size = cb->addr_size;
 146         int argc,envc,arglen,envlen;
 147         const char **argv = cb->init_argv;
 148         const char **envp = cb->init_envp;
 149
 150         argc = arglen = 0;
 151         if (argv)
 152           {
 153             for ( ; argv[argc]; ++argc)
 154               arglen += strlen (argv[argc]) + 1;
 155           }
 156         envc = envlen = 0;
 157         if (envp)
 158           {
 159             for ( ; envp[envc]; ++envc)
 160               envlen += strlen (envp[envc]) + 1;
 161           }
 162         result = arglen + envlen;
 163         break;
 164       }
 165
 166     case CB_SYS_argv :
 167       {
 168         /* Pointer to target's buffer.  */
 169         TADDR tbuf = sc->arg1;
 170         /* Buffer size.  */
 171         int bufsize = sc->arg2;
 172         /* Q is the target address of where all the strings go.  */
 173         TADDR q;
 174         int word_size = cb->word_size;
 175         int i,argc,envc,len;
 176         const char **argv = cb->init_argv;
 177         const char **envp = cb->init_envp;
 178
 179         argc = 0;
 180         if (argv)
 181           {
 182             for ( ; argv[argc]; ++argc)
 183               {
 184                 int len = strlen (argv[argc]);
 185                 int written = (*sc->write_mem) (cb, sc, tbuf, argv[argc], len + 1);
 186                 if (written != len)
 187                   {
 188                     result = -1;
 189                     errcode = EINVAL;
 190                     goto FinishSyscall;
 191                   }
 192                 tbuf = len + 1;
 193               }
 194           }
 195         if ((*sc->write_mem) (cb, sc, tbuf, "", 1) != 1)
 196           {
 197             result = -1;
 198             errcode = EINVAL;
 199             goto FinishSyscall;
 200           }
 201         tbuf++;
 202         envc = 0;
 203         if (envp)
 204           {
 205             for ( ; envp[envc]; ++envc)
 206               {
 207                 int len = strlen (envp[envc]);
 208                 int written = (*sc->write_mem) (cb, sc, tbuf, envp[envc], len + 1);
 209                 if (written != len)
 210                   {
 211                     result = -1;
 212                     errcode = EINVAL;
 213                     goto FinishSyscall;
 214                   }
 215                 tbuf = len + 1;
 216               }
 217           }
 218         if ((*sc->write_mem) (cb, sc, tbuf, "", 1) != 1)
 219           {
 220             result = -1;
 221             errcode = EINVAL;
 222             goto FinishSyscall;
 223           }
 224         result = argc;
 225         sc->result2 = envc;
 226         break;
 227       }
 228 #endif /* wip */
 229
 230     case CB_SYS_exit :
 231       /* Caller must catch and handle.  */
 232       break;
 233
 234     case CB_SYS_open :
 235       {
 236         char *path;
 237
 238         errcode = get_path (cb, sc, sc->arg1, &path);
 239         if (errcode != 0)
 240           {
 241             result = -1;
 242             goto FinishSyscall;
 243           }
 244         result = (*cb->open) (cb, path, sc->arg2 /*, sc->arg3*/);
 245         free (path);
 246         if (result < 0)
 247           goto ErrorFinish;
 248       }
 249       break;
 250
 251     case CB_SYS_close :
 252       result = (*cb->close) (cb, sc->arg1);
 253       if (result < 0)
 254         goto ErrorFinish;
 255       break;
 256
 257     case CB_SYS_read :
 258       {
 259         /* ??? Perfect handling of error conditions may require only one
 260            call to cb->read.  One can't assume all the data is
 261            contiguously stored in host memory so that would require
 262            malloc'ing/free'ing the space.  Maybe later.  */
 263         char buf[FILE_XFR_SIZE];
 264         int fd = sc->arg1;
 265         TADDR addr = sc->arg2;
 266         size_t count = sc->arg3;
 267         size_t bytes_read = 0;
 268         int bytes_written;
 269
 270         while (count > 0)
 271           {
 272             if (fd == 0)
 273               result = (int) (*cb->read_stdin) (cb, buf,
 274                                                 (count < FILE_XFR_SIZE
 275                                                  ? count : FILE_XFR_SIZE));
 276             else
 277               result = (int) (*cb->read) (cb, fd, buf,
 278                                           (count < FILE_XFR_SIZE
 279                                            ? count : FILE_XFR_SIZE));
 280             if (result == -1)
 281               goto ErrorFinish;
 282             bytes_written = (*sc->write_mem) (cb, sc, addr, buf, result);
 283             if (bytes_written != result)
 284               {
 285                 result = -1;
 286                 errcode = EINVAL;
 287                 goto FinishSyscall;
 288               }
 289             bytes_read += result;
 290             count -= result;
 291             addr += result;
 292           }
 293         result = bytes_read;
 294       }
 295       break;
 296
 297     case CB_SYS_write :
 298       {
 299         /* ??? Perfect handling of error conditions may require only one
 300            call to cb->write.  One can't assume all the data is
 301            contiguously stored in host memory so that would require
 302            malloc'ing/free'ing the space.  Maybe later.  */
 303         char buf[FILE_XFR_SIZE];
 304         int fd = sc->arg1;
 305         TADDR addr = sc->arg2;
 306         size_t count = sc->arg3;
 307         int bytes_read;
 308         size_t bytes_written = 0;
 309
 310         while (count > 0)
 311           {
 312             int bytes_to_read = count < FILE_XFR_SIZE ? count : FILE_XFR_SIZE;
 313             bytes_read = (*sc->read_mem) (cb, sc, addr, buf, bytes_to_read);
 314             if (bytes_read != bytes_to_read)
 315               {
 316                 result = -1;
 317                 errcode = EINVAL;
 318                 goto FinishSyscall;
 319               }
 320             if (fd == 1)
 321               result = (int) (*cb->write_stdout) (cb, buf, bytes_read);
 322             if (fd == 2)
 323               result = (int) (*cb->write_stderr) (cb, buf, bytes_read);
 324             else
 325               result = (int) (*cb->write) (cb, fd, buf, bytes_read);
 326             if (result == -1)
 327               goto ErrorFinish;
 328             bytes_written += result;
 329             count -= result;
 330             addr += result;
 331           }
 332         result = bytes_written;
 333       }
 334       break;
 335
 336     case CB_SYS_lseek :
 337       {
 338         int fd = sc->arg1;
 339         unsigned long offset = sc->arg2;
 340         int whence = sc->arg3;
 341
 342         result = (*cb->lseek) (cb, fd, offset, whence);
 343         if (result < 0)
 344           goto ErrorFinish;
 345       }
 346       break;
 347
 348     case CB_SYS_unlink :
 349       {
 350         char *path;
 351
 352         errcode = get_path (cb, sc, sc->arg1, &path);
 353         if (errcode != 0)
 354           {
 355             result = -1;
 356             goto FinishSyscall;
 357           }
 358         result = (*cb->unlink) (cb, path);
 359         free (path);
 360         if (result < 0)
 361           goto ErrorFinish;
 362       }
 363       break;
 364
 365     case CB_SYS_stat :
 366       {
 367         char *path,*buf;
 368         int buflen;
 369         struct stat statbuf;
 370         TADDR addr = sc->arg2;
 371
 372         errcode = get_path (cb, sc, sc->arg1, &path);
 373         if (errcode != 0)
 374           {
 375             result = -1;
 376             goto FinishSyscall;
 377           }
 378         result = (*cb->stat) (cb, path, &statbuf);
 379         free (path);
 380         if (result < 0)
 381           goto ErrorFinish;
 382         buflen = cb_host_to_target_stat (cb, NULL, NULL);
 383         buf = xmalloc (buflen);
 384         if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
 385           {
 386             /* The translation failed.  This is due to an internal
 387                host program error, not the target's fault.  */
 388             free (buf);
 389             errcode = ENOSYS;
 390             result = -1;
 391             goto FinishSyscall;
 392           }
 393         if ((*sc->write_mem) (cb, sc, addr, buf, buflen) != buflen)
 394           {
 395             free (buf);
 396             errcode = EINVAL;
 397             result = -1;
 398             goto FinishSyscall;
 399           }
 400         free (buf);
 401       }
 402       break;
 403
 404     case CB_SYS_fstat :
 405       {
 406         char *buf;
 407         int buflen;
 408         struct stat statbuf;
 409         TADDR addr = sc->arg2;
 410
 411         result = (*cb->fstat) (cb, sc->arg1, &statbuf);
 412         if (result < 0)
 413           goto ErrorFinish;
 414         buflen = cb_host_to_target_stat (cb, NULL, NULL);
 415         buf = xmalloc (buflen);
 416         if (cb_host_to_target_stat (cb, &statbuf, buf) != buflen)
 417           {
 418             /* The translation failed.  This is due to an internal
 419                host program error, not the target's fault.  */
 420             free (buf);
 421             errcode = ENOSYS;
 422             result = -1;
 423             goto FinishSyscall;
 424           }
 425         if ((*sc->write_mem) (cb, sc, addr, buf, buflen) != buflen)
 426           {
 427             free (buf);
 428             errcode = EINVAL;
 429             result = -1;
 430             goto FinishSyscall;
 431           }
 432         free (buf);
 433       }
 434       break;
 435
 436     case CB_SYS_time :
 437       {
 438         /* FIXME: May wish to change CB_SYS_time to something else.
 439            We might also want gettimeofday or times, but if system calls
 440            can be built on others, we can keep the number we have to support
 441            here down.  */
 442         time_t t = (*cb->time) (cb, (time_t *) 0);
 443         result = t;
 444         /* It is up to target code to process the argument to time().  */
 445       }
 446       break;
 447
 448     case CB_SYS_chdir :
 449     case CB_SYS_chmod :
 450     case CB_SYS_utime :
 451       /* fall through for now */
 452
 453     default :
 454       result = -1;
 455       errcode = ENOSYS;
 456       break;
 457     }
 458
 459  FinishSyscall:
 460   sc->result = result;
 461   if (errcode == 0)
 462     sc->errcode = 0;
 463   else
 464     sc->errcode = cb_host_to_target_errno (cb, errcode);
 465   return CB_RC_OK;
 466
 467  ErrorFinish:
 468   sc->result = result;
 469   sc->errcode = (*cb->get_errno) (cb);
 470   return CB_RC_OK;
 471 }