X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finf-child.c;h=7909b0c2a42d344263f9c61abad691a10db248fa;hb=a12ac51333cf97f4da0597d049cc694b4535e7dd;hp=8a99adc01c46ac9c88f7e37ed055acc51e346b42;hpb=4ebfc96eba45f869ad109fdb7d1149bb4af3b3a2;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/inf-child.c b/gdb/inf-child.c index 8a99adc01c..7909b0c2a4 100644 --- a/gdb/inf-child.c +++ b/gdb/inf-child.c @@ -1,6 +1,6 @@ /* Base/prototype target for default child (native) targets. - Copyright (C) 1988-2014 Free Software Foundation, Inc. + Copyright (C) 1988-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -28,10 +28,9 @@ #include "symtab.h" #include "target.h" #include "inferior.h" -#include #include #include "inf-child.h" -#include "gdb/fileio.h" +#include "fileio.h" #include "agent.h" #include "gdb_wait.h" #include "filestuff.h" @@ -40,6 +39,11 @@ #include #include +/* A pointer to what is returned by inf_child_target. Used by + inf_child_open to push the most-derived target in reaction to + "target native". */ +static struct target_ops *inf_child_ops = NULL; + /* Helper function for child_wait and the derivatives of child_wait. HOSTSTATUS is the waitstatus from wait() or the equivalent; store our translation of that in OURSTATUS. */ @@ -109,10 +113,66 @@ inf_child_prepare_to_store (struct target_ops *self, { } +/* True if the user did "target native". In that case, we won't + unpush the child target automatically when the last inferior is + gone. */ +static int inf_child_explicitly_opened; + +/* See inf-child.h. */ + +void +inf_child_open_target (struct target_ops *target, const char *arg, + int from_tty) +{ + target_preopen (from_tty); + push_target (target); + inf_child_explicitly_opened = 1; + if (from_tty) + printf_filtered ("Done. Use the \"run\" command to start a process.\n"); +} + static void -inf_child_open (char *arg, int from_tty) +inf_child_open (const char *arg, int from_tty) { - error (_("Use the \"run\" command to start a process.")); + inf_child_open_target (inf_child_ops, arg, from_tty); +} + +/* Implement the to_disconnect target_ops method. */ + +static void +inf_child_disconnect (struct target_ops *target, const char *args, int from_tty) +{ + if (args != NULL) + error (_("Argument given to \"disconnect\".")); + + /* This offers to detach/kill current inferiors, and then pops all + targets. */ + target_preopen (from_tty); +} + +/* Implement the to_close target_ops method. */ + +static void +inf_child_close (struct target_ops *target) +{ + /* In case we were forcibly closed. */ + inf_child_explicitly_opened = 0; +} + +void +inf_child_mourn_inferior (struct target_ops *ops) +{ + generic_mourn_inferior (); + inf_child_maybe_unpush_target (ops); +} + +/* See inf-child.h. */ + +void +inf_child_maybe_unpush_target (struct target_ops *ops) +{ + if (!inf_child_explicitly_opened && !have_inferiors ()) + unpush_target (ops); } static void @@ -144,121 +204,34 @@ inf_child_pid_to_exec_file (struct target_ops *self, int pid) return NULL; } +/* Implementation of to_fileio_open. */ -/* Target file operations. */ - -static int -inf_child_fileio_open_flags_to_host (int fileio_open_flags, int *open_flags_p) -{ - int open_flags = 0; - - if (fileio_open_flags & ~FILEIO_O_SUPPORTED) - return -1; - - if (fileio_open_flags & FILEIO_O_CREAT) - open_flags |= O_CREAT; - if (fileio_open_flags & FILEIO_O_EXCL) - open_flags |= O_EXCL; - if (fileio_open_flags & FILEIO_O_TRUNC) - open_flags |= O_TRUNC; - if (fileio_open_flags & FILEIO_O_APPEND) - open_flags |= O_APPEND; - if (fileio_open_flags & FILEIO_O_RDONLY) - open_flags |= O_RDONLY; - if (fileio_open_flags & FILEIO_O_WRONLY) - open_flags |= O_WRONLY; - if (fileio_open_flags & FILEIO_O_RDWR) - open_flags |= O_RDWR; -/* On systems supporting binary and text mode, always open files in - binary mode. */ -#ifdef O_BINARY - open_flags |= O_BINARY; -#endif - - *open_flags_p = open_flags; - return 0; -} - -static int -inf_child_errno_to_fileio_error (int errnum) -{ - switch (errnum) - { - case EPERM: - return FILEIO_EPERM; - case ENOENT: - return FILEIO_ENOENT; - case EINTR: - return FILEIO_EINTR; - case EIO: - return FILEIO_EIO; - case EBADF: - return FILEIO_EBADF; - case EACCES: - return FILEIO_EACCES; - case EFAULT: - return FILEIO_EFAULT; - case EBUSY: - return FILEIO_EBUSY; - case EEXIST: - return FILEIO_EEXIST; - case ENODEV: - return FILEIO_ENODEV; - case ENOTDIR: - return FILEIO_ENOTDIR; - case EISDIR: - return FILEIO_EISDIR; - case EINVAL: - return FILEIO_EINVAL; - case ENFILE: - return FILEIO_ENFILE; - case EMFILE: - return FILEIO_EMFILE; - case EFBIG: - return FILEIO_EFBIG; - case ENOSPC: - return FILEIO_ENOSPC; - case ESPIPE: - return FILEIO_ESPIPE; - case EROFS: - return FILEIO_EROFS; - case ENOSYS: - return FILEIO_ENOSYS; - case ENAMETOOLONG: - return FILEIO_ENAMETOOLONG; - } - return FILEIO_EUNKNOWN; -} - -/* Open FILENAME on the target, using FLAGS and MODE. Return a - target file descriptor, or -1 if an error occurs (and set - *TARGET_ERRNO). */ static int inf_child_fileio_open (struct target_ops *self, - const char *filename, int flags, int mode, + struct inferior *inf, const char *filename, + int flags, int mode, int warn_if_slow, int *target_errno) { int nat_flags; + mode_t nat_mode; int fd; - if (inf_child_fileio_open_flags_to_host (flags, &nat_flags) == -1) + if (fileio_to_host_openflags (flags, &nat_flags) == -1 + || fileio_to_host_mode (mode, &nat_mode) == -1) { *target_errno = FILEIO_EINVAL; return -1; } - /* We do not need to convert MODE, since the fileio protocol uses - the standard values. */ - fd = gdb_open_cloexec (filename, nat_flags, mode); + fd = gdb_open_cloexec (filename, nat_flags, nat_mode); if (fd == -1) - *target_errno = inf_child_errno_to_fileio_error (errno); + *target_errno = host_to_fileio_error (errno); return fd; } -/* Write up to LEN bytes from WRITE_BUF to FD on the target. - Return the number of bytes written, or -1 if an error occurs - (and set *TARGET_ERRNO). */ +/* Implementation of to_fileio_pwrite. */ + static int inf_child_fileio_pwrite (struct target_ops *self, int fd, const gdb_byte *write_buf, int len, @@ -280,14 +253,13 @@ inf_child_fileio_pwrite (struct target_ops *self, } if (ret == -1) - *target_errno = inf_child_errno_to_fileio_error (errno); + *target_errno = host_to_fileio_error (errno); return ret; } -/* Read up to LEN bytes FD on the target into READ_BUF. - Return the number of bytes read, or -1 if an error occurs - (and set *TARGET_ERRNO). */ +/* Implementation of to_fileio_pread. */ + static int inf_child_fileio_pread (struct target_ops *self, int fd, gdb_byte *read_buf, int len, @@ -309,13 +281,28 @@ inf_child_fileio_pread (struct target_ops *self, } if (ret == -1) - *target_errno = inf_child_errno_to_fileio_error (errno); + *target_errno = host_to_fileio_error (errno); return ret; } -/* Close FD on the target. Return 0, or -1 if an error occurs - (and set *TARGET_ERRNO). */ +/* Implementation of to_fileio_fstat. */ + +static int +inf_child_fileio_fstat (struct target_ops *self, int fd, + struct stat *sb, int *target_errno) +{ + int ret; + + ret = fstat (fd, sb); + if (ret == -1) + *target_errno = host_to_fileio_error (errno); + + return ret; +} + +/* Implementation of to_fileio_close. */ + static int inf_child_fileio_close (struct target_ops *self, int fd, int *target_errno) { @@ -323,36 +310,37 @@ inf_child_fileio_close (struct target_ops *self, int fd, int *target_errno) ret = close (fd); if (ret == -1) - *target_errno = inf_child_errno_to_fileio_error (errno); + *target_errno = host_to_fileio_error (errno); return ret; } -/* Unlink FILENAME on the target. Return 0, or -1 if an error - occurs (and set *TARGET_ERRNO). */ +/* Implementation of to_fileio_unlink. */ + static int inf_child_fileio_unlink (struct target_ops *self, - const char *filename, int *target_errno) + struct inferior *inf, const char *filename, + int *target_errno) { int ret; ret = unlink (filename); if (ret == -1) - *target_errno = inf_child_errno_to_fileio_error (errno); + *target_errno = host_to_fileio_error (errno); return ret; } -/* Read value of symbolic link FILENAME on the target. Return a - null-terminated string allocated via xmalloc, or NULL if an error - occurs (and set *TARGET_ERRNO). */ +/* Implementation of to_fileio_readlink. */ + static char * inf_child_fileio_readlink (struct target_ops *self, - const char *filename, int *target_errno) + struct inferior *inf, const char *filename, + int *target_errno) { /* We support readlink only on systems that also provide a compile-time maximum path length (PATH_MAX), at least for now. */ -#if defined (HAVE_READLINK) && defined (PATH_MAX) +#if defined (PATH_MAX) char buf[PATH_MAX]; int len; char *ret; @@ -360,11 +348,11 @@ inf_child_fileio_readlink (struct target_ops *self, len = readlink (filename, buf, sizeof buf); if (len < 0) { - *target_errno = inf_child_errno_to_fileio_error (errno); + *target_errno = host_to_fileio_error (errno); return NULL; } - ret = xmalloc (len + 1); + ret = (char *) xmalloc (len + 1); memcpy (ret, buf, len); ret[len] = '\0'; return ret; @@ -410,6 +398,8 @@ inf_child_target (void) t->to_longname = "Native process"; t->to_doc = "Native process (started by the \"run\" command)."; t->to_open = inf_child_open; + t->to_close = inf_child_close; + t->to_disconnect = inf_child_disconnect; t->to_post_attach = inf_child_post_attach; t->to_fetch_registers = inf_child_fetch_inferior_registers; t->to_store_registers = inf_child_store_inferior_registers; @@ -419,7 +409,6 @@ inf_child_target (void) t->to_terminal_init = child_terminal_init; t->to_terminal_inferior = child_terminal_inferior; t->to_terminal_ours_for_output = child_terminal_ours_for_output; - t->to_terminal_save_ours = child_terminal_save_ours; t->to_terminal_ours = child_terminal_ours; t->to_terminal_info = child_terminal_info; t->to_post_startup_inferior = inf_child_post_startup_inferior; @@ -439,11 +428,17 @@ inf_child_target (void) t->to_fileio_open = inf_child_fileio_open; t->to_fileio_pwrite = inf_child_fileio_pwrite; t->to_fileio_pread = inf_child_fileio_pread; + t->to_fileio_fstat = inf_child_fileio_fstat; t->to_fileio_close = inf_child_fileio_close; t->to_fileio_unlink = inf_child_fileio_unlink; t->to_fileio_readlink = inf_child_fileio_readlink; t->to_magic = OPS_MAGIC; t->to_use_agent = inf_child_use_agent; t->to_can_use_agent = inf_child_can_use_agent; + + /* Store a pointer so we can push the most-derived target from + inf_child_open. */ + inf_child_ops = t; + return t; }