From 6b8edb5101861228778b7c2d014e20c5ba0c156a Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Tue, 22 May 2018 18:22:11 +0100 Subject: remote: one struct remote_state per struct remote_target 'struct remote_state' today contains per-connection state, however there's only a single global instance of that type. In order to support multiple connections, we must have one such object per connection. Thus this patch eliminates the 'remote_state' global in favor of having a remote_state instance per remote_target instance. The get_remote_state free function is eliminated as well, by making it a remote_target method instead. The patch then fixes the fallout by making all free functions that refer to get_remote_state() directly or indirectly be methods of remote_target too. Likewise, remote-fileio.c and remote-notif.c routines are parameterized with a remote_target pointer too, so they can call into the right remote_target instance. References to the global 'get_remote_state ()->remote_desc' to tell whether the remote target is open (!= nullptr) must be replaced with something else: - Command implementations use a new get_current_remote_target free function. - remote_target::open_1 checks the exception type instead. Finally, remote_target and extended_remote_target are made heap-allocated targets. As with the earlier core target patches, it still won't be possible to have more than one remote_target instance in practice, but this puts us closer. gdb/ChangeLog: 2018-05-22 Pedro Alves * remote-fileio.c (remote_fileio_reply, remote_fileio_ioerror) (remote_fileio_badfd, remote_fileio_return_errno) (remote_fileio_return_success, remote_fileio_func_open) (remote_fileio_func_open, remote_fileio_func_close) (remote_fileio_func_read, remote_fileio_func_write) (remote_fileio_func_lseek, remote_fileio_func_rename) (remote_fileio_func_unlink, remote_fileio_func_stat) (remote_fileio_func_fstat, remote_fileio_func_gettimeofday) (remote_fileio_func_isatty, remote_fileio_func_system): Add remote_target parameter. (remote_fio_func_map) : Add remote_target parameter. (do_remote_fileio_request, remote_fileio_request): * remote-fileio.h (remote_fileio_request): * remote-notif.c (remote_notif_ack, remote_notif_parse, ): Add remote_target parameter. (remote_notif_process, handle_notification): Adjust to pass down the remote. (remote_notif_state_allocate): Add remote_target parameter. Save it. * remote-notif.h (struct remote_target): Forward declare. (struct notif_client) : Add remote_target parameter. (struct remote_notif_state) : New field. (remote_notif_ack, remote_notif_parse): Add remote_target parameter. (remote_notif_state_allocate, remote_notif_state_allocate): Add remote_target parameter. * remote.c (OPAQUETHREADBYTES, threadref, gdb_ext_thread_info) (threads_listing_context, rmt_thread_action, protocol_feature) (packet_reg, stop_reply, stop_reply_p, enum packet_support) (packet_result, struct threads_listing_context, remote_state): Move definitions and declarations higher up. (remote_target) <~remote_target>: Declare. (remote_download_command_source, remote_file_put, remote_file_get) (remote_file_delete, remote_hostio_pread, remote_hostio_pwrite) (remote_hostio_pread_vFile, remote_hostio_send_command) (remote_hostio_set_filesystem, remote_hostio_open) (remote_hostio_close, remote_hostio_unlink, remote_state) (get_remote_state, get_remote_packet_size, get_memory_packet_size) (get_memory_write_packet_size, get_memory_read_packet_size) (append_pending_thread_resumptions, remote_detach_1) (append_resumption, remote_resume_with_vcont) (add_current_inferior_and_thread, wait_ns, wait_as) (process_stop_reply, remote_notice_new_inferior) (process_initial_stop_replies, remote_add_thread) (btrace_sync_conf, remote_btrace_maybe_reopen) (remove_new_fork_children, kill_new_fork_children) (discard_pending_stop_replies, stop_reply_queue_length) (check_pending_events_prevent_wildcard_vcont) (discard_pending_stop_replies_in_queue, stop_reply) (remote_notif_remove_queued_reply, stop_reply *queued_stop_reply) (peek_stop_reply, remote_parse_stop_reply, remote_stop_ns) (remote_interrupt_as, remote_interrupt_ns) (remote_get_noisy_reply, remote_query_attached) (remote_add_inferior, remote_current_thread, get_current_thread) (set_thread, set_general_thread, set_continue_thread) (set_general_process, write_ptid) (remote_unpack_thread_info_response, remote_get_threadinfo) (parse_threadlist_response, remote_get_threadlist) (remote_threadlist_iterator, remote_get_threads_with_ql) (remote_get_threads_with_qxfer) (remote_get_threads_with_qthreadinfo, extended_remote_restart) (get_offsets, remote_check_symbols, remote_supported_packet) (remote_query_supported, remote_packet_size) (remote_serial_quit_handler, remote_detach_pid) (remote_vcont_probe, remote_resume_with_hc) (send_interrupt_sequence, interrupt_query) (remote_notif_get_pending_events, fetch_register_using_p) (send_g_packet, process_g_packet, fetch_registers_using_g) (store_register_using_P, store_registers_using_G) (set_remote_traceframe, check_binary_download) (remote_write_bytes_aux, remote_write_bytes, remote_read_bytes_1) (remote_xfer_live_readonly_partial, remote_read_bytes) (remote_send_printf, remote_flash_write, readchar) (remote_serial_write, putpkt, putpkt_binary, skip_frame) (read_frame, getpkt, getpkt_or_notif_sane_1, getpkt_sane) (getpkt_or_notif_sane, remote_vkill, remote_kill_k) (extended_remote_disable_randomization, extended_remote_run) (send_environment_packet, extended_remote_environment_support) (extended_remote_set_inferior_cwd, remote_write_qxfer) (remote_read_qxfer, push_stop_reply, vcont_r_supported) (packet_command): Now methods of ... (remote_target): ... this class. (m_remote_state) : New field. (struct remote_state) : New fields. (remote_state::remote_state): Allocate stop_reply_queue. (remote_state): Delete global. (get_remote_state_raw): Delete. (remote_target::get_remote_state): Allocate m_remote_state on demand. (get_current_remote_target): New. (remote_ops, extended_remote_ops): Delete. (wait_forever_enabled_p, remote_async_inferior_event_token): Delete, moved to struct remote_state. (remote_target::close): Delete self. Destruction bits split to ... (remote_target::~remote_target): ... this. (show_memory_packet_size): Adjust to use get_current_remote_target. (struct protocol_feature) : Add remote_target parameter. All callers adjusted. (curr_quit_handler_target): New. (remote_serial_quit_handler): Reimplement. (remote_target::open_1): Adjust to use get_current_remote_target. Heap-allocate remote_target/extended_remote_target instances. (vcont_builder::vcont_builder): Add remote_target parameter, and save it in m_remote. All callers adjusted. (vcont_builder::m_remote): New field. (vcont_builder::restart, vcont_builder::flush) (vcont_builder::push_action): Use it. (remote_target::commit_resume): Use it. (struct queue_iter_param) : New field. (remote_target::remove_new_fork_children): Fill in 'remote' field. (check_pending_event_prevents_wildcard_vcont_callback_data): New. (check_pending_event_prevents_wildcard_vcont_callback) (remote_target::check_pending_events_prevent_wildcard_vcont) (remote_target::discard_pending_stop_replies) (remote_target::discard_pending_stop_replies_in_queue) (remote_target::remote_notif_remove_queued_reply): Fill in 'remote' field. (remote_notif_get_pending_events): New. (remote_target::readchar, remote_target::remote_serial_write): Save/restore curr_quit_handler_target. (putpkt): New. (kill_new_fork_children): Fill in 'remote' field. (packet_command): Use get_current_remote_target, defer to remote_target method of same name. (scoped_remote_fd::scoped_remote_fd): Add 'remote_target' parameter, and save it in m_remote. All callers adjusted. (scoped_remote_fd::release): Use m_remote. (scoped_remote_fd::m_remote): New field. (remote_file_put, remote_file_get, remote_file_delete): Use get_current_remote_target, defer to remote_target method of same name. (remote_btrace_reset): Add remote_state paremeter. Update all callers. (remote_async_inferior_event_handler). Pass down 'data'. (remote_new_objfile): Use get_current_remote_target. (remote_target::vcont_r_supported): New. (set_range_stepping): Use get_current_remote_target and remote_target::vcont_r_supported. (_initialize_remote): Don't allocate 'remote_state' and 'stop_reply_queue' globals. * remote.h (struct remote_target): Forward declare. (getpkt, putpkt, remote_notif_get_pending_events): Add 'remote_target' parameter. --- gdb/remote-fileio.c | 214 ++++++++++++++++++++++++++-------------------------- 1 file changed, 107 insertions(+), 107 deletions(-) (limited to 'gdb/remote-fileio.c') diff --git a/gdb/remote-fileio.c b/gdb/remote-fileio.c index 4c648a9..313da64 100644 --- a/gdb/remote-fileio.c +++ b/gdb/remote-fileio.c @@ -313,7 +313,7 @@ remote_fileio_quit_handler (void) } static void -remote_fileio_reply (int retcode, int error) +remote_fileio_reply (remote_target *remote, int retcode, int error) { char buf[32]; int ctrl_c = check_quit_flag (); @@ -339,36 +339,36 @@ remote_fileio_reply (int retcode, int error) strcat (buf, ",C"); } quit_handler = remote_fileio_o_quit_handler; - putpkt (buf); + putpkt (remote, buf); } static void -remote_fileio_ioerror (void) +remote_fileio_ioerror (remote_target *remote) { - remote_fileio_reply (-1, FILEIO_EIO); + remote_fileio_reply (remote, -1, FILEIO_EIO); } static void -remote_fileio_badfd (void) +remote_fileio_badfd (remote_target *remote) { - remote_fileio_reply (-1, FILEIO_EBADF); + remote_fileio_reply (remote, -1, FILEIO_EBADF); } static void -remote_fileio_return_errno (int retcode) +remote_fileio_return_errno (remote_target *remote, int retcode) { - remote_fileio_reply (retcode, retcode < 0 + remote_fileio_reply (remote, retcode, retcode < 0 ? host_to_fileio_error (errno) : 0); } static void -remote_fileio_return_success (int retcode) +remote_fileio_return_success (remote_target *remote, int retcode) { - remote_fileio_reply (retcode, 0); + remote_fileio_reply (remote, retcode, 0); } static void -remote_fileio_func_open (char *buf) +remote_fileio_func_open (remote_target *remote, char *buf) { CORE_ADDR ptrval; int length; @@ -381,20 +381,20 @@ remote_fileio_func_open (char *buf) /* 1. Parameter: Ptr to pathname / length incl. trailing zero. */ if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } /* 2. Parameter: open flags */ if (remote_fileio_extract_int (&buf, &num)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } flags = remote_fileio_oflags_to_host (num); /* 3. Parameter: open mode */ if (remote_fileio_extract_int (&buf, &num)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } mode = remote_fileio_mode_to_host (num, 1); @@ -403,7 +403,7 @@ remote_fileio_func_open (char *buf) pathname = (char *) alloca (length); if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } @@ -414,13 +414,13 @@ remote_fileio_func_open (char *buf) { if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) { - remote_fileio_reply (-1, FILEIO_ENODEV); + remote_fileio_reply (remote, -1, FILEIO_ENODEV); return; } if (S_ISDIR (st.st_mode) && ((flags & O_WRONLY) == O_WRONLY || (flags & O_RDWR) == O_RDWR)) { - remote_fileio_reply (-1, FILEIO_EISDIR); + remote_fileio_reply (remote, -1, FILEIO_EISDIR); return; } } @@ -428,16 +428,16 @@ remote_fileio_func_open (char *buf) fd = gdb_open_cloexec (pathname, flags, mode); if (fd < 0) { - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); return; } fd = remote_fileio_fd_to_targetfd (fd); - remote_fileio_return_success (fd); + remote_fileio_return_success (remote, fd); } static void -remote_fileio_func_close (char *buf) +remote_fileio_func_close (remote_target *remote, char *buf) { long num; int fd; @@ -445,24 +445,24 @@ remote_fileio_func_close (char *buf) /* Parameter: file descriptor */ if (remote_fileio_extract_int (&buf, &num)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } fd = remote_fileio_map_fd ((int) num); if (fd == FIO_FD_INVALID) { - remote_fileio_badfd (); + remote_fileio_badfd (remote); return; } if (fd != FIO_FD_CONSOLE_IN && fd != FIO_FD_CONSOLE_OUT && close (fd)) - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); remote_fileio_close_target_fd ((int) num); - remote_fileio_return_success (0); + remote_fileio_return_success (remote, 0); } static void -remote_fileio_func_read (char *buf) +remote_fileio_func_read (remote_target *remote, char *buf) { long target_fd, num; LONGEST lnum; @@ -475,26 +475,26 @@ remote_fileio_func_read (char *buf) /* 1. Parameter: file descriptor */ if (remote_fileio_extract_int (&buf, &target_fd)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } fd = remote_fileio_map_fd ((int) target_fd); if (fd == FIO_FD_INVALID) { - remote_fileio_badfd (); + remote_fileio_badfd (remote); return; } /* 2. Parameter: buffer pointer */ if (remote_fileio_extract_long (&buf, &lnum)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } ptrval = (CORE_ADDR) lnum; /* 3. Parameter: buffer length */ if (remote_fileio_extract_int (&buf, &num)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } length = (size_t) num; @@ -502,7 +502,7 @@ remote_fileio_func_read (char *buf) switch (fd) { case FIO_FD_CONSOLE_OUT: - remote_fileio_badfd (); + remote_fileio_badfd (remote); return; case FIO_FD_CONSOLE_IN: { @@ -580,15 +580,15 @@ remote_fileio_func_read (char *buf) } if (ret < 0) - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); else - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); xfree (buffer); } static void -remote_fileio_func_write (char *buf) +remote_fileio_func_write (remote_target *remote, char *buf) { long target_fd, num; LONGEST lnum; @@ -600,26 +600,26 @@ remote_fileio_func_write (char *buf) /* 1. Parameter: file descriptor */ if (remote_fileio_extract_int (&buf, &target_fd)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } fd = remote_fileio_map_fd ((int) target_fd); if (fd == FIO_FD_INVALID) { - remote_fileio_badfd (); + remote_fileio_badfd (remote); return; } /* 2. Parameter: buffer pointer */ if (remote_fileio_extract_long (&buf, &lnum)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } ptrval = (CORE_ADDR) lnum; /* 3. Parameter: buffer length */ if (remote_fileio_extract_int (&buf, &num)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } length = (size_t) num; @@ -628,14 +628,14 @@ remote_fileio_func_write (char *buf) if (target_read_memory (ptrval, buffer, length) != 0) { xfree (buffer); - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } switch (fd) { case FIO_FD_CONSOLE_IN: - remote_fileio_badfd (); + remote_fileio_badfd (remote); xfree (buffer); return; case FIO_FD_CONSOLE_OUT: @@ -653,15 +653,15 @@ remote_fileio_func_write (char *buf) } if (ret < 0) - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); else - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); xfree (buffer); } static void -remote_fileio_func_lseek (char *buf) +remote_fileio_func_lseek (remote_target *remote, char *buf) { long num; LONGEST lnum; @@ -671,50 +671,50 @@ remote_fileio_func_lseek (char *buf) /* 1. Parameter: file descriptor */ if (remote_fileio_extract_int (&buf, &num)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } fd = remote_fileio_map_fd ((int) num); if (fd == FIO_FD_INVALID) { - remote_fileio_badfd (); + remote_fileio_badfd (remote); return; } else if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT) { - remote_fileio_reply (-1, FILEIO_ESPIPE); + remote_fileio_reply (remote, -1, FILEIO_ESPIPE); return; } /* 2. Parameter: offset */ if (remote_fileio_extract_long (&buf, &lnum)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } offset = (off_t) lnum; /* 3. Parameter: flag */ if (remote_fileio_extract_int (&buf, &num)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } if (remote_fileio_seek_flag_to_host (num, &flag)) { - remote_fileio_reply (-1, FILEIO_EINVAL); + remote_fileio_reply (remote, -1, FILEIO_EINVAL); return; } ret = lseek (fd, offset, flag); if (ret == (off_t) -1) - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); else - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); } static void -remote_fileio_func_rename (char *buf) +remote_fileio_func_rename (remote_target *remote, char *buf) { CORE_ADDR old_ptr, new_ptr; int old_len, new_len; @@ -725,14 +725,14 @@ remote_fileio_func_rename (char *buf) /* 1. Parameter: Ptr to oldpath / length incl. trailing zero */ if (remote_fileio_extract_ptr_w_len (&buf, &old_ptr, &old_len)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } /* 2. Parameter: Ptr to newpath / length incl. trailing zero */ if (remote_fileio_extract_ptr_w_len (&buf, &new_ptr, &new_len)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } @@ -740,7 +740,7 @@ remote_fileio_func_rename (char *buf) oldpath = (char *) alloca (old_len); if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } @@ -748,7 +748,7 @@ remote_fileio_func_rename (char *buf) newpath = (char *) alloca (new_len); if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } @@ -758,7 +758,7 @@ remote_fileio_func_rename (char *buf) if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode)) || (!nf && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode))) { - remote_fileio_reply (-1, FILEIO_EACCES); + remote_fileio_reply (remote, -1, FILEIO_EACCES); return; } @@ -800,14 +800,14 @@ remote_fileio_func_rename (char *buf) } #endif - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); } else - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); } static void -remote_fileio_func_unlink (char *buf) +remote_fileio_func_unlink (remote_target *remote, char *buf) { CORE_ADDR ptrval; int length; @@ -818,14 +818,14 @@ remote_fileio_func_unlink (char *buf) /* Parameter: Ptr to pathname / length incl. trailing zero */ if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } /* Request pathname using 'm' packet */ pathname = (char *) alloca (length); if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } @@ -833,20 +833,20 @@ remote_fileio_func_unlink (char *buf) the correct return code). */ if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) { - remote_fileio_reply (-1, FILEIO_ENODEV); + remote_fileio_reply (remote, -1, FILEIO_ENODEV); return; } ret = unlink (pathname); if (ret == -1) - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); else - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); } static void -remote_fileio_func_stat (char *buf) +remote_fileio_func_stat (remote_target *remote, char *buf) { CORE_ADDR statptr, nameptr; int ret, namelength; @@ -858,14 +858,14 @@ remote_fileio_func_stat (char *buf) /* 1. Parameter: Ptr to pathname / length incl. trailing zero */ if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } /* 2. Parameter: Ptr to struct stat */ if (remote_fileio_extract_long (&buf, &lnum)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } statptr = (CORE_ADDR) lnum; @@ -874,7 +874,7 @@ remote_fileio_func_stat (char *buf) pathname = (char *) alloca (namelength); if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } @@ -882,13 +882,13 @@ remote_fileio_func_stat (char *buf) if (ret == -1) { - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); return; } /* Only operate on regular files and directories. */ if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) { - remote_fileio_reply (-1, FILEIO_EACCES); + remote_fileio_reply (remote, -1, FILEIO_EACCES); return; } if (statptr) @@ -899,15 +899,15 @@ remote_fileio_func_stat (char *buf) errno = target_write_memory (statptr, (gdb_byte *) &fst, sizeof fst); if (errno != 0) { - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); return; } } - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); } static void -remote_fileio_func_fstat (char *buf) +remote_fileio_func_fstat (remote_target *remote, char *buf) { CORE_ADDR ptrval; int fd, ret; @@ -920,19 +920,19 @@ remote_fileio_func_fstat (char *buf) /* 1. Parameter: file descriptor */ if (remote_fileio_extract_int (&buf, &target_fd)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } fd = remote_fileio_map_fd ((int) target_fd); if (fd == FIO_FD_INVALID) { - remote_fileio_badfd (); + remote_fileio_badfd (remote); return; } /* 2. Parameter: Ptr to struct stat */ if (remote_fileio_extract_long (&buf, &lnum)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } ptrval = (CORE_ADDR) lnum; @@ -966,7 +966,7 @@ remote_fileio_func_fstat (char *buf) if (ret == -1) { - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); return; } if (ptrval) @@ -976,15 +976,15 @@ remote_fileio_func_fstat (char *buf) errno = target_write_memory (ptrval, (gdb_byte *) &fst, sizeof fst); if (errno != 0) { - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); return; } } - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); } static void -remote_fileio_func_gettimeofday (char *buf) +remote_fileio_func_gettimeofday (remote_target *remote, char *buf) { LONGEST lnum; CORE_ADDR ptrval; @@ -995,20 +995,20 @@ remote_fileio_func_gettimeofday (char *buf) /* 1. Parameter: struct timeval pointer */ if (remote_fileio_extract_long (&buf, &lnum)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } ptrval = (CORE_ADDR) lnum; /* 2. Parameter: some pointer value... */ if (remote_fileio_extract_long (&buf, &lnum)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } /* ...which has to be NULL. */ if (lnum) { - remote_fileio_reply (-1, FILEIO_EINVAL); + remote_fileio_reply (remote, -1, FILEIO_EINVAL); return; } @@ -1016,7 +1016,7 @@ remote_fileio_func_gettimeofday (char *buf) if (ret == -1) { - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); return; } @@ -1027,15 +1027,15 @@ remote_fileio_func_gettimeofday (char *buf) errno = target_write_memory (ptrval, (gdb_byte *) &ftv, sizeof ftv); if (errno != 0) { - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); return; } } - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); } static void -remote_fileio_func_isatty (char *buf) +remote_fileio_func_isatty (remote_target *remote, char *buf) { long target_fd; int fd; @@ -1043,16 +1043,16 @@ remote_fileio_func_isatty (char *buf) /* Parameter: file descriptor */ if (remote_fileio_extract_int (&buf, &target_fd)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } fd = remote_fileio_map_fd ((int) target_fd); - remote_fileio_return_success (fd == FIO_FD_CONSOLE_IN || - fd == FIO_FD_CONSOLE_OUT ? 1 : 0); + int ret = fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT ? 1 : 0; + remote_fileio_return_success (remote, ret); } static void -remote_fileio_func_system (char *buf) +remote_fileio_func_system (remote_target *remote, char *buf) { CORE_ADDR ptrval; int ret, length; @@ -1061,7 +1061,7 @@ remote_fileio_func_system (char *buf) /* Parameter: Ptr to commandline / length incl. trailing zero */ if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length)) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } @@ -1071,7 +1071,7 @@ remote_fileio_func_system (char *buf) cmdline = (char *) alloca (length); if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0) { - remote_fileio_ioerror (); + remote_fileio_ioerror (remote); return; } } @@ -1083,25 +1083,25 @@ remote_fileio_func_system (char *buf) if (!remote_fio_system_call_allowed) { if (!length) - remote_fileio_return_success (0); + remote_fileio_return_success (remote, 0); else - remote_fileio_reply (-1, FILEIO_EPERM); + remote_fileio_reply (remote, -1, FILEIO_EPERM); return; } ret = system (cmdline); if (!length) - remote_fileio_return_success (ret); + remote_fileio_return_success (remote, ret); else if (ret == -1) - remote_fileio_return_errno (-1); + remote_fileio_return_errno (remote, -1); else - remote_fileio_return_success (WEXITSTATUS (ret)); + remote_fileio_return_success (remote, WEXITSTATUS (ret)); } static struct { const char *name; - void (*func)(char *); + void (*func)(remote_target *remote, char *); } remote_fio_func_map[] = { { "open", remote_fileio_func_open }, { "close", remote_fileio_func_close }, @@ -1119,7 +1119,7 @@ static struct { }; static void -do_remote_fileio_request (char *buf) +do_remote_fileio_request (remote_target *remote, char *buf) { char *c; int idx; @@ -1135,9 +1135,9 @@ do_remote_fileio_request (char *buf) if (!strcmp (remote_fio_func_map[idx].name, buf)) break; if (!remote_fio_func_map[idx].name) - remote_fileio_reply (-1, FILEIO_ENOSYS); + remote_fileio_reply (remote, -1, FILEIO_ENOSYS); else - remote_fio_func_map[idx].func (c); + remote_fio_func_map[idx].func (remote, c); } /* Close any open descriptors, and reinitialize the file mapping. */ @@ -1167,7 +1167,7 @@ remote_fileio_reset (void) acknowledged the Ctrl-C sent asynchronously earlier. */ void -remote_fileio_request (char *buf, int ctrlc_pending_p) +remote_fileio_request (remote_target *remote, char *buf, int ctrlc_pending_p) { /* Save the previous quit handler, so we can restore it. No need for a cleanup since we catch all exceptions below. Note that the @@ -1181,20 +1181,20 @@ remote_fileio_request (char *buf, int ctrlc_pending_p) asynchronously earlier, take this opportunity to send the Ctrl-C synchronously. */ set_quit_flag (); - remote_fileio_reply (-1, FILEIO_EINTR); + remote_fileio_reply (remote, -1, FILEIO_EINTR); } else { TRY { - do_remote_fileio_request (buf); + do_remote_fileio_request (remote, buf); } CATCH (ex, RETURN_MASK_ALL) { if (ex.reason == RETURN_QUIT) - remote_fileio_reply (-1, FILEIO_EINTR); + remote_fileio_reply (remote, -1, FILEIO_EINTR); else - remote_fileio_reply (-1, FILEIO_EIO); + remote_fileio_reply (remote, -1, FILEIO_EIO); } END_CATCH } -- cgit v1.1