sim/rx/syscalls.c

   1 /* syscalls.c --- implement system calls for the RX simulator.
   2
   3 Copyright (C) 2005-2020 Free Software Foundation, Inc.
   4 Contributed by Red Hat, Inc.
   5
   6 This file is part of the GNU simulators.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21
  22 #include "config.h"
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27 #include <sys/time.h>
  28
  29 #include "gdb/callback.h"
  30
  31 #include "cpu.h"
  32 #include "mem.h"
  33 #include "syscalls.h"
  34
  35 #include "syscall.h"
  36
  37 /* The current syscall callbacks we're using.  */
  38 static struct host_callback_struct *callbacks;
  39
  40 void
  41 set_callbacks (struct host_callback_struct *cb)
  42 {
  43   callbacks = cb;
  44 }
  45
  46 struct host_callback_struct *
  47 get_callbacks (void)
  48 {
  49   return callbacks;
  50 }
  51
  52
  53 /* Arguments 1..4 are in R1..R4, remainder on stack.
  54
  55    Return value in R1..R4 as needed.
  56      structs bigger than 16 bytes: pointer pushed on stack last
  57
  58    We only support arguments that fit in general registers.
  59
  60    The system call number is in R5.  We expect ssycalls to look like
  61    this in libgloss:
  62
  63    _exit:
  64         mov     #SYS_exit, r5
  65         int     #255
  66         rts
  67 */
  68
  69 int argp, stackp;
  70
  71 static int
  72 arg ()
  73 {
  74   int rv = 0;
  75   argp++;
  76
  77   if (argp < 4)
  78     return get_reg (argp);
  79
  80   rv = mem_get_si (get_reg (sp) + stackp);
  81   stackp += 4;
  82   return rv;
  83 }
  84
  85 static void
  86 read_target (char *buffer, int address, int count, int asciiz)
  87 {
  88   char byte;
  89   while (count > 0)
  90     {
  91       byte = mem_get_qi (address++);
  92       *buffer++ = byte;
  93       if (asciiz && (byte == 0))
  94         return;
  95       count--;
  96     }
  97 }
  98
  99 static void
 100 write_target (char *buffer, int address, int count, int asciiz)
 101 {
 102   char byte;
 103   while (count > 0)
 104     {
 105       byte = *buffer++;
 106       mem_put_qi (address++, byte);
 107       if (asciiz && (byte == 0))
 108         return;
 109       count--;
 110     }
 111 }
 112
 113 #define PTRSZ (A16 ? 2 : 3)
 114
 115 static char *callnames[] = {
 116   "SYS_zero",
 117   "SYS_exit",
 118   "SYS_open",
 119   "SYS_close",
 120   "SYS_read",
 121   "SYS_write",
 122   "SYS_lseek",
 123   "SYS_unlink",
 124   "SYS_getpid",
 125   "SYS_kill",
 126   "SYS_fstat",
 127   "SYS_sbrk",
 128   "SYS_argvlen",
 129   "SYS_argv",
 130   "SYS_chdir",
 131   "SYS_stat",
 132   "SYS_chmod",
 133   "SYS_utime",
 134   "SYS_time",
 135   "SYS_gettimeofday",
 136   "SYS_times",
 137   "SYS_link"
 138 };
 139
 140 int
 141 rx_syscall (int id)
 142 {
 143   static char buf[256];
 144   int rv;
 145
 146   argp = 0;
 147   stackp = 4;
 148   if (trace)
 149     printf ("\033[31m/* SYSCALL(%d) = %s */\033[0m\n", id, id <= SYS_link ? callnames[id] : "unknown");
 150   switch (id)
 151     {
 152     case SYS_exit:
 153       {
 154         int ec = arg ();
 155         if (verbose)
 156           printf ("[exit %d]\n", ec);
 157         return RX_MAKE_EXITED (ec);
 158       }
 159       break;
 160
 161     case SYS_open:
 162       {
 163         int path = arg ();
 164         /* The open function is defined as taking a variable number of arguments
 165            because the third parameter to it is optional:
 166              open (const char * filename, int flags, ...);
 167            Hence the oflags and cflags arguments will be on the stack and we need
 168            to skip the (empty) argument registers r3 and r4.  */
 169         argp = 4;
 170         int oflags = arg ();
 171         int cflags = arg ();
 172
 173         read_target (buf, path, 256, 1);
 174         if (trace)
 175           printf ("open(\"%s\",0x%x,%#o) = ", buf, oflags, cflags);
 176
 177         if (callbacks)
 178           /* The callback vector ignores CFLAGS.  */
 179           rv = callbacks->open (callbacks, buf, oflags);
 180         else
 181           {
 182             int h_oflags = 0;
 183
 184             if (oflags & 0x0001)
 185               h_oflags |= O_WRONLY;
 186             if (oflags & 0x0002)
 187               h_oflags |= O_RDWR;
 188             if (oflags & 0x0200)
 189               h_oflags |= O_CREAT;
 190             if (oflags & 0x0008)
 191               h_oflags |= O_APPEND;
 192             if (oflags & 0x0400)
 193               h_oflags |= O_TRUNC;
 194             rv = open (buf, h_oflags, cflags);
 195           }
 196         if (trace)
 197           printf ("%d\n", rv);
 198         put_reg (1, rv);
 199       }
 200       break;
 201
 202     case SYS_close:
 203       {
 204         int fd = arg ();
 205
 206         if (callbacks)
 207           rv = callbacks->close (callbacks, fd);
 208         else if (fd > 2)
 209           rv = close (fd);
 210         else
 211           rv = 0;
 212         if (trace)
 213           printf ("close(%d) = %d\n", fd, rv);
 214         put_reg (1, rv);
 215       }
 216       break;
 217
 218     case SYS_read:
 219       {
 220         int fd = arg ();
 221         int addr = arg ();
 222         int count = arg ();
 223
 224         if (count > sizeof (buf))
 225           count = sizeof (buf);
 226         if (callbacks)
 227           rv = callbacks->read (callbacks, fd, buf, count);
 228         else
 229           rv = read (fd, buf, count);
 230         if (trace)
 231           printf ("read(%d,%d) = %d\n", fd, count, rv);
 232         if (rv > 0)
 233           write_target (buf, addr, rv, 0);
 234         put_reg (1, rv);
 235       }
 236       break;
 237
 238     case SYS_write:
 239       {
 240         int fd = arg ();
 241         int addr = arg ();
 242         int count = arg ();
 243
 244         if (count > sizeof (buf))
 245           count = sizeof (buf);
 246         if (trace)
 247           printf ("write(%d,0x%x,%d)\n", fd, addr, count);
 248         read_target (buf, addr, count, 0);
 249         if (trace)
 250           fflush (stdout);
 251         if (callbacks)
 252           rv = callbacks->write (callbacks, fd, buf, count);
 253         else
 254           rv = write (fd, buf, count);
 255         if (trace)
 256           printf ("write(%d,%d) = %d\n", fd, count, rv);
 257         put_reg (1, rv);
 258       }
 259       break;
 260
 261     case SYS_getpid:
 262       put_reg (1, 42);
 263       break;
 264
 265     case SYS_gettimeofday:
 266       {
 267         int tvaddr = arg ();
 268         struct timeval tv;
 269
 270         rv = gettimeofday (&tv, 0);
 271         if (trace)
 272           printf ("gettimeofday: %ld sec %ld usec to 0x%x\n", tv.tv_sec,
 273                   tv.tv_usec, tvaddr);
 274         mem_put_si (tvaddr, tv.tv_sec);
 275         mem_put_si (tvaddr + 4, tv.tv_usec);
 276         put_reg (1, rv);
 277       }
 278       break;
 279
 280     case SYS_kill:
 281       {
 282         int pid = arg ();
 283         int sig = arg ();
 284         if (pid == 42)
 285           {
 286             if (verbose)
 287               printf ("[signal %d]\n", sig);
 288             return RX_MAKE_STOPPED (sig);
 289           }
 290       }
 291       break;
 292
 293     case 11:
 294       {
 295         int heaptop_arg = arg ();
 296         if (trace)
 297           printf ("sbrk: heap top set to %x\n", heaptop_arg);
 298         heaptop = heaptop_arg;
 299         if (heapbottom == 0)
 300           heapbottom = heaptop_arg;
 301       }
 302       break;
 303
 304     case 255:
 305       {
 306         int addr = arg ();
 307         mem_put_si (addr, rx_cycles + mem_usage_cycles());
 308       }
 309       break;
 310
 311     }
 312   return RX_MAKE_STEPPED ();
 313 }