gdb/inf-child.c

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