gdb/inf-child.c

   1 /* Base/prototype target for default child (native) targets.
   2
   3    Copyright (C) 1988-2018 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 "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 (regcache->arch ());
  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 /* Implementation of to_fileio_open.  */
 208
 209 static int
 210 inf_child_fileio_open (struct target_ops *self,
 211                        struct inferior *inf, const char *filename,
 212                        int flags, int mode, int warn_if_slow,
 213                        int *target_errno)
 214 {
 215   int nat_flags;
 216   mode_t nat_mode;
 217   int fd;
 218
 219   if (fileio_to_host_openflags (flags, &nat_flags) == -1
 220       || fileio_to_host_mode (mode, &nat_mode) == -1)
 221     {
 222       *target_errno = FILEIO_EINVAL;
 223       return -1;
 224     }
 225
 226   fd = gdb_open_cloexec (filename, nat_flags, nat_mode);
 227   if (fd == -1)
 228     *target_errno = host_to_fileio_error (errno);
 229
 230   return fd;
 231 }
 232
 233 /* Implementation of to_fileio_pwrite.  */
 234
 235 static int
 236 inf_child_fileio_pwrite (struct target_ops *self,
 237                          int fd, const gdb_byte *write_buf, int len,
 238                          ULONGEST offset, int *target_errno)
 239 {
 240   int ret;
 241
 242 #ifdef HAVE_PWRITE
 243   ret = pwrite (fd, write_buf, len, (long) offset);
 244 #else
 245   ret = -1;
 246 #endif
 247   /* If we have no pwrite or it failed for this file, use lseek/write.  */
 248   if (ret == -1)
 249     {
 250       ret = lseek (fd, (long) offset, SEEK_SET);
 251       if (ret != -1)
 252         ret = write (fd, write_buf, len);
 253     }
 254
 255   if (ret == -1)
 256     *target_errno = host_to_fileio_error (errno);
 257
 258   return ret;
 259 }
 260
 261 /* Implementation of to_fileio_pread.  */
 262
 263 static int
 264 inf_child_fileio_pread (struct target_ops *self,
 265                         int fd, gdb_byte *read_buf, int len,
 266                         ULONGEST offset, int *target_errno)
 267 {
 268   int ret;
 269
 270 #ifdef HAVE_PREAD
 271   ret = pread (fd, read_buf, len, (long) offset);
 272 #else
 273   ret = -1;
 274 #endif
 275   /* If we have no pread or it failed for this file, use lseek/read.  */
 276   if (ret == -1)
 277     {
 278       ret = lseek (fd, (long) offset, SEEK_SET);
 279       if (ret != -1)
 280         ret = read (fd, read_buf, len);
 281     }
 282
 283   if (ret == -1)
 284     *target_errno = host_to_fileio_error (errno);
 285
 286   return ret;
 287 }
 288
 289 /* Implementation of to_fileio_fstat.  */
 290
 291 static int
 292 inf_child_fileio_fstat (struct target_ops *self, int fd,
 293                         struct stat *sb, int *target_errno)
 294 {
 295   int ret;
 296
 297   ret = fstat (fd, sb);
 298   if (ret == -1)
 299     *target_errno = host_to_fileio_error (errno);
 300
 301   return ret;
 302 }
 303
 304 /* Implementation of to_fileio_close.  */
 305
 306 static int
 307 inf_child_fileio_close (struct target_ops *self, int fd, int *target_errno)
 308 {
 309   int ret;
 310
 311   ret = close (fd);
 312   if (ret == -1)
 313     *target_errno = host_to_fileio_error (errno);
 314
 315   return ret;
 316 }
 317
 318 /* Implementation of to_fileio_unlink.  */
 319
 320 static int
 321 inf_child_fileio_unlink (struct target_ops *self,
 322                          struct inferior *inf, const char *filename,
 323                          int *target_errno)
 324 {
 325   int ret;
 326
 327   ret = unlink (filename);
 328   if (ret == -1)
 329     *target_errno = host_to_fileio_error (errno);
 330
 331   return ret;
 332 }
 333
 334 /* Implementation of to_fileio_readlink.  */
 335
 336 static char *
 337 inf_child_fileio_readlink (struct target_ops *self,
 338                            struct inferior *inf, const char *filename,
 339                            int *target_errno)
 340 {
 341   /* We support readlink only on systems that also provide a compile-time
 342      maximum path length (PATH_MAX), at least for now.  */
 343 #if defined (PATH_MAX)
 344   char buf[PATH_MAX];
 345   int len;
 346   char *ret;
 347
 348   len = readlink (filename, buf, sizeof buf);
 349   if (len < 0)
 350     {
 351       *target_errno = host_to_fileio_error (errno);
 352       return NULL;
 353     }
 354
 355   ret = (char *) xmalloc (len + 1);
 356   memcpy (ret, buf, len);
 357   ret[len] = '\0';
 358   return ret;
 359 #else
 360   *target_errno = FILEIO_ENOSYS;
 361   return NULL;
 362 #endif
 363 }
 364
 365 static int
 366 inf_child_use_agent (struct target_ops *self, int use)
 367 {
 368   if (agent_loaded_p ())
 369     {
 370       use_agent = use;
 371       return 1;
 372     }
 373   else
 374     return 0;
 375 }
 376
 377 static int
 378 inf_child_can_use_agent (struct target_ops *self)
 379 {
 380   return agent_loaded_p ();
 381 }
 382
 383 /* Default implementation of the to_can_async_p and
 384    to_supports_non_stop methods.  */
 385
 386 static int
 387 return_zero (struct target_ops *ignore)
 388 {
 389   return 0;
 390 }
 391
 392 struct target_ops *
 393 inf_child_target (void)
 394 {
 395   struct target_ops *t = XCNEW (struct target_ops);
 396
 397   t->to_shortname = "native";
 398   t->to_longname = "Native process";
 399   t->to_doc = "Native process (started by the \"run\" command).";
 400   t->to_open = inf_child_open;
 401   t->to_close = inf_child_close;
 402   t->to_disconnect = inf_child_disconnect;
 403   t->to_post_attach = inf_child_post_attach;
 404   t->to_fetch_registers = inf_child_fetch_inferior_registers;
 405   t->to_store_registers = inf_child_store_inferior_registers;
 406   t->to_prepare_to_store = inf_child_prepare_to_store;
 407   t->to_insert_breakpoint = memory_insert_breakpoint;
 408   t->to_remove_breakpoint = memory_remove_breakpoint;
 409   t->to_terminal_init = child_terminal_init;
 410   t->to_terminal_inferior = child_terminal_inferior;
 411   t->to_terminal_ours_for_output = child_terminal_ours_for_output;
 412   t->to_terminal_ours = child_terminal_ours;
 413   t->to_terminal_info = child_terminal_info;
 414   t->to_post_startup_inferior = inf_child_post_startup_inferior;
 415   t->to_follow_fork = inf_child_follow_fork;
 416   t->to_can_run = inf_child_can_run;
 417   /* We must default these because they must be implemented by any
 418      target that can run.  */
 419   t->to_can_async_p = return_zero;
 420   t->to_supports_non_stop = return_zero;
 421   t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
 422   t->to_stratum = process_stratum;
 423   t->to_has_all_memory = default_child_has_all_memory;
 424   t->to_has_memory = default_child_has_memory;
 425   t->to_has_stack = default_child_has_stack;
 426   t->to_has_registers = default_child_has_registers;
 427   t->to_has_execution = default_child_has_execution;
 428   t->to_fileio_open = inf_child_fileio_open;
 429   t->to_fileio_pwrite = inf_child_fileio_pwrite;
 430   t->to_fileio_pread = inf_child_fileio_pread;
 431   t->to_fileio_fstat = inf_child_fileio_fstat;
 432   t->to_fileio_close = inf_child_fileio_close;
 433   t->to_fileio_unlink = inf_child_fileio_unlink;
 434   t->to_fileio_readlink = inf_child_fileio_readlink;
 435   t->to_magic = OPS_MAGIC;
 436   t->to_use_agent = inf_child_use_agent;
 437   t->to_can_use_agent = inf_child_can_use_agent;
 438
 439   /* Store a pointer so we can push the most-derived target from
 440      inf_child_open.  */
 441   inf_child_ops = t;
 442
 443   return t;
 444 }