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 static const target_info inf_child_target_info = {
  43   "native",
  44   N_("Native process"),
  45   N_("Native process (started by the \"run\" command).")
  46 };
  47
  48 const target_info &
  49 inf_child_target::info () const
  50 {
  51   return inf_child_target_info;
  52 }
  53
  54 /* Helper function for child_wait and the derivatives of child_wait.
  55    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
  56    translation of that in OURSTATUS.  */
  57 void
  58 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
  59 {
  60   if (WIFEXITED (hoststatus))
  61     {
  62       ourstatus->kind = TARGET_WAITKIND_EXITED;
  63       ourstatus->value.integer = WEXITSTATUS (hoststatus);
  64     }
  65   else if (!WIFSTOPPED (hoststatus))
  66     {
  67       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
  68       ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (hoststatus));
  69     }
  70   else
  71     {
  72       ourstatus->kind = TARGET_WAITKIND_STOPPED;
  73       ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (hoststatus));
  74     }
  75 }
  76
  77 inf_child_target::~inf_child_target ()
  78 {}
  79
  80 void
  81 inf_child_target::post_attach (int pid)
  82 {
  83   /* This target doesn't require a meaningful "post attach" operation
  84      by a debugger.  */
  85 }
  86
  87 /* Get ready to modify the registers array.  On machines which store
  88    individual registers, this doesn't need to do anything.  On
  89    machines which store all the registers in one fell swoop, this
  90    makes sure that registers contains all the registers from the
  91    program being debugged.  */
  92
  93 void
  94 inf_child_target::prepare_to_store (struct regcache *regcache)
  95 {
  96 }
  97
  98 bool
  99 inf_child_target::supports_terminal_ours ()
 100 {
 101   return true;
 102 }
 103
 104 void
 105 inf_child_target::terminal_init ()
 106 {
 107   child_terminal_init (this);
 108 }
 109
 110 void
 111 inf_child_target::terminal_inferior ()
 112 {
 113   child_terminal_inferior (this);
 114 }
 115
 116 void
 117 inf_child_target::terminal_ours_for_output ()
 118 {
 119   child_terminal_ours_for_output (this);
 120 }
 121
 122 void
 123 inf_child_target::terminal_ours ()
 124 {
 125   child_terminal_ours (this);
 126 }
 127
 128 void
 129 inf_child_target::interrupt ()
 130 {
 131   child_interrupt (this);
 132 }
 133
 134 void
 135 inf_child_target::pass_ctrlc ()
 136 {
 137   child_pass_ctrlc (this);
 138 }
 139
 140 void
 141 inf_child_target::terminal_info (const char *args, int from_tty)
 142 {
 143   child_terminal_info (this, args, from_tty);
 144 }
 145
 146 /* True if the user did "target native".  In that case, we won't
 147    unpush the child target automatically when the last inferior is
 148    gone.  */
 149 static int inf_child_explicitly_opened;
 150
 151 /* See inf-child.h.  */
 152
 153 void
 154 inf_child_open_target (const char *arg, int from_tty)
 155 {
 156   target_ops *target = get_native_target ();
 157
 158   /* There's always only ever one native target, and if we get here,
 159      it better be an inf-child target.  */
 160   gdb_assert (dynamic_cast<inf_child_target *> (target) != NULL);
 161
 162   target_preopen (from_tty);
 163   push_target (target);
 164   inf_child_explicitly_opened = 1;
 165   if (from_tty)
 166     printf_filtered ("Done.  Use the \"run\" command to start a process.\n");
 167 }
 168
 169 /* Implement the to_disconnect target_ops method.  */
 170
 171 void
 172 inf_child_target::disconnect (const char *args, int from_tty)
 173 {
 174   if (args != NULL)
 175     error (_("Argument given to \"disconnect\"."));
 176
 177   /* This offers to detach/kill current inferiors, and then pops all
 178      targets.  */
 179   target_preopen (from_tty);
 180 }
 181
 182 /* Implement the to_close target_ops method.  */
 183
 184 void
 185 inf_child_target::close ()
 186 {
 187   /* In case we were forcibly closed.  */
 188   inf_child_explicitly_opened = 0;
 189 }
 190
 191 void
 192 inf_child_target::mourn_inferior ()
 193 {
 194   generic_mourn_inferior ();
 195   maybe_unpush_target ();
 196 }
 197
 198 /* See inf-child.h.  */
 199
 200 void
 201 inf_child_target::maybe_unpush_target ()
 202 {
 203   if (!inf_child_explicitly_opened && !have_inferiors ())
 204     unpush_target (this);
 205 }
 206
 207 void
 208 inf_child_target::post_startup_inferior (ptid_t ptid)
 209 {
 210   /* This target doesn't require a meaningful "post startup inferior"
 211      operation by a debugger.  */
 212 }
 213
 214 bool
 215 inf_child_target::can_run ()
 216 {
 217   return true;
 218 }
 219
 220 bool
 221 inf_child_target::can_create_inferior ()
 222 {
 223   return true;
 224 }
 225
 226 bool
 227 inf_child_target::can_attach ()
 228 {
 229   return true;
 230 }
 231
 232 char *
 233 inf_child_target::pid_to_exec_file (int pid)
 234 {
 235   /* This target doesn't support translation of a process ID to the
 236      filename of the executable file.  */
 237   return NULL;
 238 }
 239
 240 bool
 241 inf_child_target::has_all_memory ()
 242 {
 243   return default_child_has_all_memory ();
 244 }
 245
 246 bool
 247 inf_child_target::has_memory ()
 248 {
 249   return default_child_has_memory ();
 250 }
 251
 252 bool
 253 inf_child_target::has_stack ()
 254 {
 255   return default_child_has_stack ();
 256 }
 257
 258 bool
 259 inf_child_target::has_registers ()
 260 {
 261   return default_child_has_registers ();
 262 }
 263
 264 bool
 265 inf_child_target::has_execution (ptid_t ptid)
 266 {
 267   return default_child_has_execution (ptid);
 268 }
 269
 270 /* Implementation of to_fileio_open.  */
 271
 272 int
 273 inf_child_target::fileio_open (struct inferior *inf, const char *filename,
 274                                int flags, int mode, int warn_if_slow,
 275                                int *target_errno)
 276 {
 277   int nat_flags;
 278   mode_t nat_mode;
 279   int fd;
 280
 281   if (fileio_to_host_openflags (flags, &nat_flags) == -1
 282       || fileio_to_host_mode (mode, &nat_mode) == -1)
 283     {
 284       *target_errno = FILEIO_EINVAL;
 285       return -1;
 286     }
 287
 288   fd = gdb_open_cloexec (filename, nat_flags, nat_mode);
 289   if (fd == -1)
 290     *target_errno = host_to_fileio_error (errno);
 291
 292   return fd;
 293 }
 294
 295 /* Implementation of to_fileio_pwrite.  */
 296
 297 int
 298 inf_child_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
 299                                  ULONGEST offset, int *target_errno)
 300 {
 301   int ret;
 302
 303 #ifdef HAVE_PWRITE
 304   ret = pwrite (fd, write_buf, len, (long) offset);
 305 #else
 306   ret = -1;
 307 #endif
 308   /* If we have no pwrite or it failed for this file, use lseek/write.  */
 309   if (ret == -1)
 310     {
 311       ret = lseek (fd, (long) offset, SEEK_SET);
 312       if (ret != -1)
 313         ret = write (fd, write_buf, len);
 314     }
 315
 316   if (ret == -1)
 317     *target_errno = host_to_fileio_error (errno);
 318
 319   return ret;
 320 }
 321
 322 /* Implementation of to_fileio_pread.  */
 323
 324 int
 325 inf_child_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
 326                                 ULONGEST offset, int *target_errno)
 327 {
 328   int ret;
 329
 330 #ifdef HAVE_PREAD
 331   ret = pread (fd, read_buf, len, (long) offset);
 332 #else
 333   ret = -1;
 334 #endif
 335   /* If we have no pread or it failed for this file, use lseek/read.  */
 336   if (ret == -1)
 337     {
 338       ret = lseek (fd, (long) offset, SEEK_SET);
 339       if (ret != -1)
 340         ret = read (fd, read_buf, len);
 341     }
 342
 343   if (ret == -1)
 344     *target_errno = host_to_fileio_error (errno);
 345
 346   return ret;
 347 }
 348
 349 /* Implementation of to_fileio_fstat.  */
 350
 351 int
 352 inf_child_target::fileio_fstat (int fd, struct stat *sb, int *target_errno)
 353 {
 354   int ret;
 355
 356   ret = fstat (fd, sb);
 357   if (ret == -1)
 358     *target_errno = host_to_fileio_error (errno);
 359
 360   return ret;
 361 }
 362
 363 /* Implementation of to_fileio_close.  */
 364
 365 int
 366 inf_child_target::fileio_close (int fd, int *target_errno)
 367 {
 368   int ret;
 369
 370   ret = ::close (fd);
 371   if (ret == -1)
 372     *target_errno = host_to_fileio_error (errno);
 373
 374   return ret;
 375 }
 376
 377 /* Implementation of to_fileio_unlink.  */
 378
 379 int
 380 inf_child_target::fileio_unlink (struct inferior *inf, const char *filename,
 381                                  int *target_errno)
 382 {
 383   int ret;
 384
 385   ret = unlink (filename);
 386   if (ret == -1)
 387     *target_errno = host_to_fileio_error (errno);
 388
 389   return ret;
 390 }
 391
 392 /* Implementation of to_fileio_readlink.  */
 393
 394 gdb::optional<std::string>
 395 inf_child_target::fileio_readlink (struct inferior *inf, const char *filename,
 396                                    int *target_errno)
 397 {
 398   /* We support readlink only on systems that also provide a compile-time
 399      maximum path length (PATH_MAX), at least for now.  */
 400 #if defined (PATH_MAX)
 401   char buf[PATH_MAX];
 402   int len;
 403
 404   len = readlink (filename, buf, sizeof buf);
 405   if (len < 0)
 406     {
 407       *target_errno = host_to_fileio_error (errno);
 408       return {};
 409     }
 410
 411   return std::string (buf, len);
 412 #else
 413   *target_errno = FILEIO_ENOSYS;
 414   return {};
 415 #endif
 416 }
 417
 418 bool
 419 inf_child_target::use_agent (bool use)
 420 {
 421   if (agent_loaded_p ())
 422     {
 423       ::use_agent = use;
 424       return true;
 425     }
 426   else
 427     return false;
 428 }
 429
 430 bool
 431 inf_child_target::can_use_agent ()
 432 {
 433   return agent_loaded_p ();
 434 }
 435
 436 inf_child_target::inf_child_target ()
 437 {
 438   this->to_stratum = process_stratum;
 439 }
 440
 441 /* See inf-child.h.  */
 442
 443 void
 444 add_inf_child_target (inf_child_target *target)
 445 {
 446   set_native_target (target);
 447   add_target (inf_child_target_info, inf_child_open_target);
 448 }