gdb/inf-child.c

   1 /* Default child (native) target interface, for GDB when running under
   2    Unix.
   3
   4    Copyright (C) 1988-1996, 1998-2002, 2004-2005, 2007-2012 Free
   5    Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "regcache.h"
  24 #include "memattr.h"
  25 #include "symtab.h"
  26 #include "target.h"
  27 #include "inferior.h"
  28 #include "gdb_string.h"
  29 #include "gdb_stat.h"
  30 #include "inf-child.h"
  31 #include "gdb/fileio.h"
  32 #include "agent.h"
  33 #include "gdb_wait.h"
  34
  35 #ifdef HAVE_SYS_PARAM_H
  36 #include <sys/param.h>          /* for MAXPATHLEN */
  37 #endif
  38 #include <sys/types.h>
  39 #include <fcntl.h>
  40 #include <unistd.h>
  41
  42 /* Helper function for child_wait and the derivatives of child_wait.
  43    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
  44    translation of that in OURSTATUS.  */
  45 void
  46 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
  47 {
  48   if (WIFEXITED (hoststatus))
  49     {
  50       ourstatus->kind = TARGET_WAITKIND_EXITED;
  51       ourstatus->value.integer = WEXITSTATUS (hoststatus);
  52     }
  53   else if (!WIFSTOPPED (hoststatus))
  54     {
  55       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
  56       ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (hoststatus));
  57     }
  58   else
  59     {
  60       ourstatus->kind = TARGET_WAITKIND_STOPPED;
  61       ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (hoststatus));
  62     }
  63 }
  64
  65 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
  66    for all registers.  */
  67
  68 static void
  69 inf_child_fetch_inferior_registers (struct target_ops *ops,
  70                                     struct regcache *regcache, int regnum)
  71 {
  72   if (regnum == -1)
  73     {
  74       for (regnum = 0;
  75            regnum < gdbarch_num_regs (get_regcache_arch (regcache));
  76            regnum++)
  77         regcache_raw_supply (regcache, regnum, NULL);
  78     }
  79   else
  80     regcache_raw_supply (regcache, regnum, NULL);
  81 }
  82
  83 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
  84    this for all registers (including the floating point registers).  */
  85
  86 static void
  87 inf_child_store_inferior_registers (struct target_ops *ops,
  88                                     struct regcache *regcache, int regnum)
  89 {
  90 }
  91
  92 static void
  93 inf_child_post_attach (int pid)
  94 {
  95   /* This version of Unix doesn't require a meaningful "post attach"
  96      operation by a debugger.  */
  97 }
  98
  99 /* Get ready to modify the registers array.  On machines which store
 100    individual registers, this doesn't need to do anything.  On
 101    machines which store all the registers in one fell swoop, this
 102    makes sure that registers contains all the registers from the
 103    program being debugged.  */
 104
 105 static void
 106 inf_child_prepare_to_store (struct regcache *regcache)
 107 {
 108 }
 109
 110 static void
 111 inf_child_open (char *arg, int from_tty)
 112 {
 113   error (_("Use the \"run\" command to start a Unix child process."));
 114 }
 115
 116 static void
 117 inf_child_post_startup_inferior (ptid_t ptid)
 118 {
 119   /* This version of Unix doesn't require a meaningful "post startup
 120      inferior" operation by a debugger.  */
 121 }
 122
 123 static int
 124 inf_child_follow_fork (struct target_ops *ops, int follow_child)
 125 {
 126   /* This version of Unix doesn't support following fork or vfork
 127      events.  */
 128   return 0;
 129 }
 130
 131 static int
 132 inf_child_can_run (void)
 133 {
 134   return 1;
 135 }
 136
 137 static char *
 138 inf_child_pid_to_exec_file (int pid)
 139 {
 140   /* This version of Unix doesn't support translation of a process ID
 141      to the filename of the executable file.  */
 142   return NULL;
 143 }
 144
 145
 146 /* Target file operations.  */
 147
 148 static int
 149 inf_child_fileio_open_flags_to_host (int fileio_open_flags, int *open_flags_p)
 150 {
 151   int open_flags = 0;
 152
 153   if (fileio_open_flags & ~FILEIO_O_SUPPORTED)
 154     return -1;
 155
 156   if (fileio_open_flags & FILEIO_O_CREAT)
 157     open_flags |= O_CREAT;
 158   if (fileio_open_flags & FILEIO_O_EXCL)
 159     open_flags |= O_EXCL;
 160   if (fileio_open_flags & FILEIO_O_TRUNC)
 161     open_flags |= O_TRUNC;
 162   if (fileio_open_flags & FILEIO_O_APPEND)
 163     open_flags |= O_APPEND;
 164   if (fileio_open_flags & FILEIO_O_RDONLY)
 165     open_flags |= O_RDONLY;
 166   if (fileio_open_flags & FILEIO_O_WRONLY)
 167     open_flags |= O_WRONLY;
 168   if (fileio_open_flags & FILEIO_O_RDWR)
 169     open_flags |= O_RDWR;
 170 /* On systems supporting binary and text mode, always open files in
 171    binary mode. */
 172 #ifdef O_BINARY
 173   open_flags |= O_BINARY;
 174 #endif
 175
 176   *open_flags_p = open_flags;
 177   return 0;
 178 }
 179
 180 static int
 181 inf_child_errno_to_fileio_error (int errnum)
 182 {
 183   switch (errnum)
 184     {
 185       case EPERM:
 186         return FILEIO_EPERM;
 187       case ENOENT:
 188         return FILEIO_ENOENT;
 189       case EINTR:
 190         return FILEIO_EINTR;
 191       case EIO:
 192         return FILEIO_EIO;
 193       case EBADF:
 194         return FILEIO_EBADF;
 195       case EACCES:
 196         return FILEIO_EACCES;
 197       case EFAULT:
 198         return FILEIO_EFAULT;
 199       case EBUSY:
 200         return FILEIO_EBUSY;
 201       case EEXIST:
 202         return FILEIO_EEXIST;
 203       case ENODEV:
 204         return FILEIO_ENODEV;
 205       case ENOTDIR:
 206         return FILEIO_ENOTDIR;
 207       case EISDIR:
 208         return FILEIO_EISDIR;
 209       case EINVAL:
 210         return FILEIO_EINVAL;
 211       case ENFILE:
 212         return FILEIO_ENFILE;
 213       case EMFILE:
 214         return FILEIO_EMFILE;
 215       case EFBIG:
 216         return FILEIO_EFBIG;
 217       case ENOSPC:
 218         return FILEIO_ENOSPC;
 219       case ESPIPE:
 220         return FILEIO_ESPIPE;
 221       case EROFS:
 222         return FILEIO_EROFS;
 223       case ENOSYS:
 224         return FILEIO_ENOSYS;
 225       case ENAMETOOLONG:
 226         return FILEIO_ENAMETOOLONG;
 227     }
 228   return FILEIO_EUNKNOWN;
 229 }
 230
 231 /* Open FILENAME on the target, using FLAGS and MODE.  Return a
 232    target file descriptor, or -1 if an error occurs (and set
 233    *TARGET_ERRNO).  */
 234 static int
 235 inf_child_fileio_open (const char *filename, int flags, int mode,
 236                        int *target_errno)
 237 {
 238   int nat_flags;
 239   int fd;
 240
 241   if (inf_child_fileio_open_flags_to_host (flags, &nat_flags) == -1)
 242     {
 243       *target_errno = FILEIO_EINVAL;
 244       return -1;
 245     }
 246
 247   /* We do not need to convert MODE, since the fileio protocol uses
 248      the standard values.  */
 249   fd = open (filename, nat_flags, mode);
 250   if (fd == -1)
 251     *target_errno = inf_child_errno_to_fileio_error (errno);
 252
 253   return fd;
 254 }
 255
 256 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
 257    Return the number of bytes written, or -1 if an error occurs
 258    (and set *TARGET_ERRNO).  */
 259 static int
 260 inf_child_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
 261                          ULONGEST offset, int *target_errno)
 262 {
 263   int ret;
 264
 265 #ifdef HAVE_PWRITE
 266   ret = pwrite (fd, write_buf, len, (long) offset);
 267 #else
 268   ret = lseek (fd, (long) offset, SEEK_SET);
 269   if (ret != -1)
 270     ret = write (fd, write_buf, len);
 271 #endif
 272
 273   if (ret == -1)
 274     *target_errno = inf_child_errno_to_fileio_error (errno);
 275
 276   return ret;
 277 }
 278
 279 /* Read up to LEN bytes FD on the target into READ_BUF.
 280    Return the number of bytes read, or -1 if an error occurs
 281    (and set *TARGET_ERRNO).  */
 282 static int
 283 inf_child_fileio_pread (int fd, gdb_byte *read_buf, int len,
 284                         ULONGEST offset, int *target_errno)
 285 {
 286   int ret;
 287
 288 #ifdef HAVE_PREAD
 289   ret = pread (fd, read_buf, len, (long) offset);
 290 #else
 291   ret = lseek (fd, (long) offset, SEEK_SET);
 292   if (ret != -1)
 293     ret = read (fd, read_buf, len);
 294 #endif
 295
 296   if (ret == -1)
 297     *target_errno = inf_child_errno_to_fileio_error (errno);
 298
 299   return ret;
 300 }
 301
 302 /* Close FD on the target.  Return 0, or -1 if an error occurs
 303    (and set *TARGET_ERRNO).  */
 304 static int
 305 inf_child_fileio_close (int fd, int *target_errno)
 306 {
 307   int ret;
 308
 309   ret = close (fd);
 310   if (ret == -1)
 311     *target_errno = inf_child_errno_to_fileio_error (errno);
 312
 313   return ret;
 314 }
 315
 316 /* Unlink FILENAME on the target.  Return 0, or -1 if an error
 317    occurs (and set *TARGET_ERRNO).  */
 318 static int
 319 inf_child_fileio_unlink (const char *filename, int *target_errno)
 320 {
 321   int ret;
 322
 323   ret = unlink (filename);
 324   if (ret == -1)
 325     *target_errno = inf_child_errno_to_fileio_error (errno);
 326
 327   return ret;
 328 }
 329
 330 /* Read value of symbolic link FILENAME on the target.  Return a
 331    null-terminated string allocated via xmalloc, or NULL if an error
 332    occurs (and set *TARGET_ERRNO).  */
 333 static char *
 334 inf_child_fileio_readlink (const char *filename, int *target_errno)
 335 {
 336   /* We support readlink only on systems that also provide a compile-time
 337      maximum path length (MAXPATHLEN), at least for now.  */
 338 #if defined (HAVE_READLINK) && defined (MAXPATHLEN)
 339   char buf[MAXPATHLEN];
 340   int len;
 341   char *ret;
 342
 343   len = readlink (filename, buf, sizeof buf);
 344   if (len < 0)
 345     {
 346       *target_errno = inf_child_errno_to_fileio_error (errno);
 347       return NULL;
 348     }
 349
 350   ret = xmalloc (len + 1);
 351   memcpy (ret, buf, len);
 352   ret[len] = '\0';
 353   return ret;
 354 #else
 355   *target_errno = FILEIO_ENOSYS;
 356   return NULL;
 357 #endif
 358 }
 359
 360 static int
 361 inf_child_use_agent (int use)
 362 {
 363   if (agent_loaded_p ())
 364     {
 365       use_agent = use;
 366       return 1;
 367     }
 368   else
 369     return 0;
 370 }
 371
 372 static int
 373 inf_child_can_use_agent (void)
 374 {
 375   return agent_loaded_p ();
 376 }
 377
 378 struct target_ops *
 379 inf_child_target (void)
 380 {
 381   struct target_ops *t = XZALLOC (struct target_ops);
 382
 383   t->to_shortname = "child";
 384   t->to_longname = "Unix child process";
 385   t->to_doc = "Unix child process (started by the \"run\" command).";
 386   t->to_open = inf_child_open;
 387   t->to_post_attach = inf_child_post_attach;
 388   t->to_fetch_registers = inf_child_fetch_inferior_registers;
 389   t->to_store_registers = inf_child_store_inferior_registers;
 390   t->to_prepare_to_store = inf_child_prepare_to_store;
 391   t->to_insert_breakpoint = memory_insert_breakpoint;
 392   t->to_remove_breakpoint = memory_remove_breakpoint;
 393   t->to_terminal_init = terminal_init_inferior;
 394   t->to_terminal_inferior = terminal_inferior;
 395   t->to_terminal_ours_for_output = terminal_ours_for_output;
 396   t->to_terminal_save_ours = terminal_save_ours;
 397   t->to_terminal_ours = terminal_ours;
 398   t->to_terminal_info = child_terminal_info;
 399   t->to_post_startup_inferior = inf_child_post_startup_inferior;
 400   t->to_follow_fork = inf_child_follow_fork;
 401   t->to_can_run = inf_child_can_run;
 402   t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
 403   t->to_stratum = process_stratum;
 404   t->to_has_all_memory = default_child_has_all_memory;
 405   t->to_has_memory = default_child_has_memory;
 406   t->to_has_stack = default_child_has_stack;
 407   t->to_has_registers = default_child_has_registers;
 408   t->to_has_execution = default_child_has_execution;
 409   t->to_fileio_open = inf_child_fileio_open;
 410   t->to_fileio_pwrite = inf_child_fileio_pwrite;
 411   t->to_fileio_pread = inf_child_fileio_pread;
 412   t->to_fileio_close = inf_child_fileio_close;
 413   t->to_fileio_unlink = inf_child_fileio_unlink;
 414   t->to_fileio_readlink = inf_child_fileio_readlink;
 415   t->to_magic = OPS_MAGIC;
 416   t->to_use_agent = inf_child_use_agent;
 417   t->to_can_use_agent = inf_child_can_use_agent;
 418   return t;
 419 }