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 "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 /* 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 = 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 } 445