gdb/inf-child.c

   1 /* Base/prototype target for default child (native) targets.
   2
   3    Copyright (C) 1988-2015 Free Software Foundation, Inc.
   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 3 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* This file provides a common base class/target that all native
  21    target implementations extend, by calling inf_child_target to get a
  22    new prototype target and then overriding target methods as
  23    necessary.  */
  24
  25 #include "defs.h"
  26 #include "regcache.h"
  27 #include "memattr.h"
  28 #include "symtab.h"
  29 #include "target.h"
  30 #include "inferior.h"
  31 #include <sys/stat.h>
  32 #include "inf-child.h"
  33 #include "gdb/fileio.h"
  34 #include "agent.h"
  35 #include "gdb_wait.h"
  36 #include "filestuff.h"
  37
  38 #include <sys/types.h>
  39 #include <fcntl.h>
  40 #include <unistd.h>
  41
  42 /* A pointer to what is returned by inf_child_target.  Used by
  43    inf_child_open to push the most-derived target in reaction to
  44    "target native".  */
  45 static struct target_ops *inf_child_ops = NULL;
  46
  47 /* Helper function for child_wait and the derivatives of child_wait.
  48    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
  49    translation of that in OURSTATUS.  */
  50 void
  51 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
  52 {
  53   if (WIFEXITED (hoststatus))
  54     {
  55       ourstatus->kind = TARGET_WAITKIND_EXITED;
  56       ourstatus->value.integer = WEXITSTATUS (hoststatus);
  57     }
  58   else if (!WIFSTOPPED (hoststatus))
  59     {
  60       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
  61       ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (hoststatus));
  62     }
  63   else
  64     {
  65       ourstatus->kind = TARGET_WAITKIND_STOPPED;
  66       ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (hoststatus));
  67     }
  68 }
  69
  70 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
  71    for all registers.  */
  72
  73 static void
  74 inf_child_fetch_inferior_registers (struct target_ops *ops,
  75                                     struct regcache *regcache, int regnum)
  76 {
  77   if (regnum == -1)
  78     {
  79       for (regnum = 0;
  80            regnum < gdbarch_num_regs (get_regcache_arch (regcache));
  81            regnum++)
  82         regcache_raw_supply (regcache, regnum, NULL);
  83     }
  84   else
  85     regcache_raw_supply (regcache, regnum, NULL);
  86 }
  87
  88 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
  89    this for all registers (including the floating point registers).  */
  90
  91 static void
  92 inf_child_store_inferior_registers (struct target_ops *ops,
  93                                     struct regcache *regcache, int regnum)
  94 {
  95 }
  96
  97 static void
  98 inf_child_post_attach (struct target_ops *self, int pid)
  99 {
 100   /* This target doesn't require a meaningful "post attach" operation
 101      by a debugger.  */
 102 }
 103
 104 /* Get ready to modify the registers array.  On machines which store
 105    individual registers, this doesn't need to do anything.  On
 106    machines which store all the registers in one fell swoop, this
 107    makes sure that registers contains all the registers from the
 108    program being debugged.  */
 109
 110 static void
 111 inf_child_prepare_to_store (struct target_ops *self,
 112                             struct regcache *regcache)
 113 {
 114 }
 115
 116 /* True if the user did "target native".  In that case, we won't
 117    unpush the child target automatically when the last inferior is
 118    gone.  */
 119 static int inf_child_explicitly_opened;
 120
 121 /* See inf-child.h.  */
 122
 123 void
 124 inf_child_open_target (struct target_ops *target, const char *arg,
 125                        int from_tty)
 126 {
 127   target_preopen (from_tty);
 128   push_target (target);
 129   inf_child_explicitly_opened = 1;
 130   if (from_tty)
 131     printf_filtered ("Done.  Use the \"run\" command to start a process.\n");
 132 }
 133
 134 static void
 135 inf_child_open (const char *arg, int from_tty)
 136 {
 137   inf_child_open_target (inf_child_ops, arg, from_tty);
 138 }
 139
 140 /* Implement the to_disconnect target_ops method.  */
 141
 142 static void
 143 inf_child_disconnect (struct target_ops *target, const char *args, int from_tty)
 144 {
 145   if (args != NULL)
 146     error (_("Argument given to \"disconnect\"."));
 147
 148   /* This offers to detach/kill current inferiors, and then pops all
 149      targets.  */
 150   target_preopen (from_tty);
 151 }
 152
 153 /* Implement the to_close target_ops method.  */
 154
 155 static void
 156 inf_child_close (struct target_ops *target)
 157 {
 158   /* In case we were forcibly closed.  */
 159   inf_child_explicitly_opened = 0;
 160 }
 161
 162 void
 163 inf_child_mourn_inferior (struct target_ops *ops)
 164 {
 165   generic_mourn_inferior ();
 166   inf_child_maybe_unpush_target (ops);
 167 }
 168
 169 /* See inf-child.h.  */
 170
 171 void
 172 inf_child_maybe_unpush_target (struct target_ops *ops)
 173 {
 174   if (!inf_child_explicitly_opened && !have_inferiors ())
 175     unpush_target (ops);
 176 }
 177
 178 static void
 179 inf_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
 180 {
 181   /* This target doesn't require a meaningful "post startup inferior"
 182      operation by a debugger.  */
 183 }
 184
 185 static int
 186 inf_child_follow_fork (struct target_ops *ops, int follow_child,
 187                        int detach_fork)
 188 {
 189   /* This target doesn't support following fork or vfork events.  */
 190   return 0;
 191 }
 192
 193 static int
 194 inf_child_can_run (struct target_ops *self)
 195 {
 196   return 1;
 197 }
 198
 199 static char *
 200 inf_child_pid_to_exec_file (struct target_ops *self, int pid)
 201 {
 202   /* This target doesn't support translation of a process ID to the
 203      filename of the executable file.  */
 204   return NULL;
 205 }
 206
 207
 208 /* Target file operations.  */
 209
 210 static int
 211 inf_child_fileio_open_flags_to_host (int fileio_open_flags, int *open_flags_p)
 212 {
 213   int open_flags = 0;
 214
 215   if (fileio_open_flags & ~FILEIO_O_SUPPORTED)
 216     return -1;
 217
 218   if (fileio_open_flags & FILEIO_O_CREAT)
 219     open_flags |= O_CREAT;
 220   if (fileio_open_flags & FILEIO_O_EXCL)
 221     open_flags |= O_EXCL;
 222   if (fileio_open_flags & FILEIO_O_TRUNC)
 223     open_flags |= O_TRUNC;
 224   if (fileio_open_flags & FILEIO_O_APPEND)
 225     open_flags |= O_APPEND;
 226   if (fileio_open_flags & FILEIO_O_RDONLY)
 227     open_flags |= O_RDONLY;
 228   if (fileio_open_flags & FILEIO_O_WRONLY)
 229     open_flags |= O_WRONLY;
 230   if (fileio_open_flags & FILEIO_O_RDWR)
 231     open_flags |= O_RDWR;
 232 /* On systems supporting binary and text mode, always open files in
 233    binary mode. */
 234 #ifdef O_BINARY
 235   open_flags |= O_BINARY;
 236 #endif
 237
 238   *open_flags_p = open_flags;
 239   return 0;
 240 }
 241
 242 static int
 243 inf_child_errno_to_fileio_error (int errnum)
 244 {
 245   switch (errnum)
 246     {
 247       case EPERM:
 248         return FILEIO_EPERM;
 249       case ENOENT:
 250         return FILEIO_ENOENT;
 251       case EINTR:
 252         return FILEIO_EINTR;
 253       case EIO:
 254         return FILEIO_EIO;
 255       case EBADF:
 256         return FILEIO_EBADF;
 257       case EACCES:
 258         return FILEIO_EACCES;
 259       case EFAULT:
 260         return FILEIO_EFAULT;
 261       case EBUSY:
 262         return FILEIO_EBUSY;
 263       case EEXIST:
 264         return FILEIO_EEXIST;
 265       case ENODEV:
 266         return FILEIO_ENODEV;
 267       case ENOTDIR:
 268         return FILEIO_ENOTDIR;
 269       case EISDIR:
 270         return FILEIO_EISDIR;
 271       case EINVAL:
 272         return FILEIO_EINVAL;
 273       case ENFILE:
 274         return FILEIO_ENFILE;
 275       case EMFILE:
 276         return FILEIO_EMFILE;
 277       case EFBIG:
 278         return FILEIO_EFBIG;
 279       case ENOSPC:
 280         return FILEIO_ENOSPC;
 281       case ESPIPE:
 282         return FILEIO_ESPIPE;
 283       case EROFS:
 284         return FILEIO_EROFS;
 285       case ENOSYS:
 286         return FILEIO_ENOSYS;
 287       case ENAMETOOLONG:
 288         return FILEIO_ENAMETOOLONG;
 289     }
 290   return FILEIO_EUNKNOWN;
 291 }
 292
 293 /* Open FILENAME on the target, using FLAGS and MODE.  Return a
 294    target file descriptor, or -1 if an error occurs (and set
 295    *TARGET_ERRNO).  */
 296 static int
 297 inf_child_fileio_open (struct target_ops *self,
 298                        const char *filename, int flags, int mode,
 299                        int *target_errno)
 300 {
 301   int nat_flags;
 302   int fd;
 303
 304   if (inf_child_fileio_open_flags_to_host (flags, &nat_flags) == -1)
 305     {
 306       *target_errno = FILEIO_EINVAL;
 307       return -1;
 308     }
 309
 310   /* We do not need to convert MODE, since the fileio protocol uses
 311      the standard values.  */
 312   fd = gdb_open_cloexec (filename, nat_flags, mode);
 313   if (fd == -1)
 314     *target_errno = inf_child_errno_to_fileio_error (errno);
 315
 316   return fd;
 317 }
 318
 319 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
 320    Return the number of bytes written, or -1 if an error occurs
 321    (and set *TARGET_ERRNO).  */
 322 static int
 323 inf_child_fileio_pwrite (struct target_ops *self,
 324                          int fd, const gdb_byte *write_buf, int len,
 325                          ULONGEST offset, int *target_errno)
 326 {
 327   int ret;
 328
 329 #ifdef HAVE_PWRITE
 330   ret = pwrite (fd, write_buf, len, (long) offset);
 331 #else
 332   ret = -1;
 333 #endif
 334   /* If we have no pwrite or it failed for this file, use lseek/write.  */
 335   if (ret == -1)
 336     {
 337       ret = lseek (fd, (long) offset, SEEK_SET);
 338       if (ret != -1)
 339         ret = write (fd, write_buf, len);
 340     }
 341
 342   if (ret == -1)
 343     *target_errno = inf_child_errno_to_fileio_error (errno);
 344
 345   return ret;
 346 }
 347
 348 /* Read up to LEN bytes FD on the target into READ_BUF.
 349    Return the number of bytes read, or -1 if an error occurs
 350    (and set *TARGET_ERRNO).  */
 351 static int
 352 inf_child_fileio_pread (struct target_ops *self,
 353                         int fd, gdb_byte *read_buf, int len,
 354                         ULONGEST offset, int *target_errno)
 355 {
 356   int ret;
 357
 358 #ifdef HAVE_PREAD
 359   ret = pread (fd, read_buf, len, (long) offset);
 360 #else
 361   ret = -1;
 362 #endif
 363   /* If we have no pread or it failed for this file, use lseek/read.  */
 364   if (ret == -1)
 365     {
 366       ret = lseek (fd, (long) offset, SEEK_SET);
 367       if (ret != -1)
 368         ret = read (fd, read_buf, len);
 369     }
 370
 371   if (ret == -1)
 372     *target_errno = inf_child_errno_to_fileio_error (errno);
 373
 374   return ret;
 375 }
 376
 377 /* Close FD on the target.  Return 0, or -1 if an error occurs
 378    (and set *TARGET_ERRNO).  */
 379 static int
 380 inf_child_fileio_close (struct target_ops *self, int fd, int *target_errno)
 381 {
 382   int ret;
 383
 384   ret = close (fd);
 385   if (ret == -1)
 386     *target_errno = inf_child_errno_to_fileio_error (errno);
 387
 388   return ret;
 389 }
 390
 391 /* Unlink FILENAME on the target.  Return 0, or -1 if an error
 392    occurs (and set *TARGET_ERRNO).  */
 393 static int
 394 inf_child_fileio_unlink (struct target_ops *self,
 395                          const char *filename, int *target_errno)
 396 {
 397   int ret;
 398
 399   ret = unlink (filename);
 400   if (ret == -1)
 401     *target_errno = inf_child_errno_to_fileio_error (errno);
 402
 403   return ret;
 404 }
 405
 406 /* Read value of symbolic link FILENAME on the target.  Return a
 407    null-terminated string allocated via xmalloc, or NULL if an error
 408    occurs (and set *TARGET_ERRNO).  */
 409 static char *
 410 inf_child_fileio_readlink (struct target_ops *self,
 411                            const char *filename, int *target_errno)
 412 {
 413   /* We support readlink only on systems that also provide a compile-time
 414      maximum path length (PATH_MAX), at least for now.  */
 415 #if defined (PATH_MAX)
 416   char buf[PATH_MAX];
 417   int len;
 418   char *ret;
 419
 420   len = readlink (filename, buf, sizeof buf);
 421   if (len < 0)
 422     {
 423       *target_errno = inf_child_errno_to_fileio_error (errno);
 424       return NULL;
 425     }
 426
 427   ret = xmalloc (len + 1);
 428   memcpy (ret, buf, len);
 429   ret[len] = '\0';
 430   return ret;
 431 #else
 432   *target_errno = FILEIO_ENOSYS;
 433   return NULL;
 434 #endif
 435 }
 436
 437 static int
 438 inf_child_use_agent (struct target_ops *self, int use)
 439 {
 440   if (agent_loaded_p ())
 441     {
 442       use_agent = use;
 443       return 1;
 444     }
 445   else
 446     return 0;
 447 }
 448
 449 static int
 450 inf_child_can_use_agent (struct target_ops *self)
 451 {
 452   return agent_loaded_p ();
 453 }
 454
 455 /* Default implementation of the to_can_async_p and
 456    to_supports_non_stop methods.  */
 457
 458 static int
 459 return_zero (struct target_ops *ignore)
 460 {
 461   return 0;
 462 }
 463
 464 struct target_ops *
 465 inf_child_target (void)
 466 {
 467   struct target_ops *t = XCNEW (struct target_ops);
 468
 469   t->to_shortname = "native";
 470   t->to_longname = "Native process";
 471   t->to_doc = "Native process (started by the \"run\" command).";
 472   t->to_open = inf_child_open;
 473   t->to_close = inf_child_close;
 474   t->to_disconnect = inf_child_disconnect;
 475   t->to_post_attach = inf_child_post_attach;
 476   t->to_fetch_registers = inf_child_fetch_inferior_registers;
 477   t->to_store_registers = inf_child_store_inferior_registers;
 478   t->to_prepare_to_store = inf_child_prepare_to_store;
 479   t->to_insert_breakpoint = memory_insert_breakpoint;
 480   t->to_remove_breakpoint = memory_remove_breakpoint;
 481   t->to_terminal_init = child_terminal_init;
 482   t->to_terminal_inferior = child_terminal_inferior;
 483   t->to_terminal_ours_for_output = child_terminal_ours_for_output;
 484   t->to_terminal_ours = child_terminal_ours;
 485   t->to_terminal_info = child_terminal_info;
 486   t->to_post_startup_inferior = inf_child_post_startup_inferior;
 487   t->to_follow_fork = inf_child_follow_fork;
 488   t->to_can_run = inf_child_can_run;
 489   /* We must default these because they must be implemented by any
 490      target that can run.  */
 491   t->to_can_async_p = return_zero;
 492   t->to_supports_non_stop = return_zero;
 493   t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
 494   t->to_stratum = process_stratum;
 495   t->to_has_all_memory = default_child_has_all_memory;
 496   t->to_has_memory = default_child_has_memory;
 497   t->to_has_stack = default_child_has_stack;
 498   t->to_has_registers = default_child_has_registers;
 499   t->to_has_execution = default_child_has_execution;
 500   t->to_fileio_open = inf_child_fileio_open;
 501   t->to_fileio_pwrite = inf_child_fileio_pwrite;
 502   t->to_fileio_pread = inf_child_fileio_pread;
 503   t->to_fileio_close = inf_child_fileio_close;
 504   t->to_fileio_unlink = inf_child_fileio_unlink;
 505   t->to_fileio_readlink = inf_child_fileio_readlink;
 506   t->to_magic = OPS_MAGIC;
 507   t->to_use_agent = inf_child_use_agent;
 508   t->to_can_use_agent = inf_child_can_use_agent;
 509
 510   /* Store a pointer so we can push the most-derived target from
 511      inf_child_open.  */
 512   inf_child_ops = t;
 513
 514   return t;
 515 }