remote.c 417 KB
Newer Older
1
/* Remote target communications for serial-line targets in custom GDB protocol
2

3
   Copyright (C) 1988-2019 Free Software Foundation, Inc.
4

5
6
7
8
   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   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
11
12
13
14
15
16
17
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   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
/* See the GDB User Guide for details of the GDB remote protocol.  */
21

22
23
24
25
#include "defs.h"
#include <ctype.h>
#include <fcntl.h>
#include "inferior.h"
Pedro Alves's avatar
Pedro Alves committed
26
#include "infrun.h"
27
28
29
#include "bfd.h"
#include "symfile.h"
#include "target.h"
Pedro Alves's avatar
Pedro Alves committed
30
#include "process-stratum-target.h"
31
/*#include "terminal.h" */
32
33
34
35
#include "gdbcmd.h"
#include "objfiles.h"
#include "gdb-stabs.h"
#include "gdbthread.h"
Jason Molenda's avatar
Jason Molenda committed
36
#include "remote.h"
Yao Qi's avatar
gdb/    
Yao Qi committed
37
#include "remote-notif.h"
38
#include "regcache.h"
39
#include "value.h"
Tom Tromey's avatar
Tom Tromey committed
40
#include "observable.h"
41
#include "solib.h"
42
43
#include "cli/cli-decode.h"
#include "cli/cli-setshow.h"
44
#include "target-descriptions.h"
45
#include "gdb_bfd.h"
Tom Tromey's avatar
Tom Tromey committed
46
#include "filestuff.h"
Tom Tromey's avatar
Tom Tromey committed
47
#include "rsp-low.h"
48
#include "disasm.h"
49
#include "location.h"
50

Pedro Alves's avatar
Pedro Alves committed
51
#include "gdb_sys_time.h"
52

Jason Molenda's avatar
Jason Molenda committed
53
#include "event-loop.h"
Jason Molenda's avatar
Jason Molenda committed
54
#include "event-top.h"
Jason Molenda's avatar
Jason Molenda committed
55
#include "inf-loop.h"
Jason Molenda's avatar
Jason Molenda committed
56

57
58
59
#include <signal.h>
#include "serial.h"

60
61
#include "gdbcore.h" /* for exec_bfd */

62
#include "remote-fileio.h"
63
#include "gdb/fileio.h"
Tom Tromey's avatar
Tom Tromey committed
64
#include <sys/stat.h>
Vladimir Prus's avatar
Vladimir Prus committed
65
#include "xml-support.h"
66

Daniel Jacobowitz's avatar
gdb/    
Daniel Jacobowitz committed
67
68
#include "memory-map.h"

69
70
71
#include "tracepoint.h"
#include "ax.h"
#include "ax-gdb.h"
Yao Qi's avatar
gdb:    
Yao Qi committed
72
#include "agent.h"
73
#include "btrace.h"
74
#include "record-btrace.h"
75
#include <algorithm>
Tom Tromey's avatar
Tom Tromey committed
76
#include "common/scoped_restore.h"
77
#include "environ.h"
78
#include "common/byte-vector.h"
79
#include <unordered_map>
80

Pedro Alves's avatar
Pedro Alves committed
81
82
/* The remote target.  */

83
84
85
86
87
static const char remote_doc[] = N_("\
Use a remote computer via a serial line, using a gdb-specific protocol.\n\
Specify the serial device it is connected to\n\
(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");

88
89
90
91
92
93
94
95
96
97
98
99
#define OPAQUETHREADBYTES 8

/* a 64 bit opaque identifier */
typedef unsigned char threadref[OPAQUETHREADBYTES];

struct gdb_ext_thread_info;
struct threads_listing_context;
typedef int (*rmt_thread_action) (threadref *ref, void *context);
struct protocol_feature;
struct packet_reg;

struct stop_reply;
Tom Tromey's avatar
Tom Tromey committed
100
static void stop_reply_xfree (struct stop_reply *);
101

Tom Tromey's avatar
Tom Tromey committed
102
103
104
105
106
107
108
109
110
struct stop_reply_deleter
{
  void operator() (stop_reply *r) const
  {
    stop_reply_xfree (r);
  }
};

typedef std::unique_ptr<stop_reply, stop_reply_deleter> stop_reply_up;
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

/* Generic configuration support for packets the stub optionally
   supports.  Allows the user to specify the use of the packet as well
   as allowing GDB to auto-detect support in the remote stub.  */

enum packet_support
  {
    PACKET_SUPPORT_UNKNOWN = 0,
    PACKET_ENABLE,
    PACKET_DISABLE
  };

/* Analyze a packet's return value and update the packet config
   accordingly.  */

enum packet_result
{
  PACKET_ERROR,
  PACKET_OK,
  PACKET_UNKNOWN
};

struct threads_listing_context;
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248

/* Stub vCont actions support.

   Each field is a boolean flag indicating whether the stub reports
   support for the corresponding action.  */

struct vCont_action_support
{
  /* vCont;t */
  bool t = false;

  /* vCont;r */
  bool r = false;

  /* vCont;s */
  bool s = false;

  /* vCont;S */
  bool S = false;
};

/* About this many threadisds fit in a packet.  */

#define MAXTHREADLISTRESULTS 32

/* Data for the vFile:pread readahead cache.  */

struct readahead_cache
{
  /* Invalidate the readahead cache.  */
  void invalidate ();

  /* Invalidate the readahead cache if it is holding data for FD.  */
  void invalidate_fd (int fd);

  /* Serve pread from the readahead cache.  Returns number of bytes
     read, or 0 if the request can't be served from the cache.  */
  int pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset);

  /* The file descriptor for the file that is being cached.  -1 if the
     cache is invalid.  */
  int fd = -1;

  /* The offset into the file that the cache buffer corresponds
     to.  */
  ULONGEST offset = 0;

  /* The buffer holding the cache contents.  */
  gdb_byte *buf = nullptr;
  /* The buffer's size.  We try to read as much as fits into a packet
     at a time.  */
  size_t bufsize = 0;

  /* Cache hit and miss counters.  */
  ULONGEST hit_count = 0;
  ULONGEST miss_count = 0;
};

/* Description of the remote protocol for a given architecture.  */

struct packet_reg
{
  long offset; /* Offset into G packet.  */
  long regnum; /* GDB's internal register number.  */
  LONGEST pnum; /* Remote protocol register number.  */
  int in_g_packet; /* Always part of G packet.  */
  /* long size in bytes;  == register_size (target_gdbarch (), regnum);
     at present.  */
  /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
     at present.  */
};

struct remote_arch_state
{
  explicit remote_arch_state (struct gdbarch *gdbarch);

  /* Description of the remote protocol registers.  */
  long sizeof_g_packet;

  /* Description of the remote protocol registers indexed by REGNUM
     (making an array gdbarch_num_regs in size).  */
  std::unique_ptr<packet_reg[]> regs;

  /* This is the size (in chars) of the first response to the ``g''
     packet.  It is used as a heuristic when determining the maximum
     size of memory-read and memory-write packets.  A target will
     typically only reserve a buffer large enough to hold the ``g''
     packet.  The size does not include packet overhead (headers and
     trailers).  */
  long actual_register_packet_size;

  /* This is the maximum size (in chars) of a non read/write packet.
     It is also used as a cap on the size of read/write packets.  */
  long remote_packet_size;
};

/* Description of the remote protocol state for the currently
   connected target.  This is per-target state, and independent of the
   selected architecture.  */

class remote_state
{
public:

  remote_state ();
  ~remote_state ();

  /* Get the remote arch state for GDBARCH.  */
  struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch);

public: /* data */

  /* A buffer to use for incoming packets, and its current size.  The
     buffer is grown dynamically for larger incoming packets.
     Outgoing packets may also be constructed in this buffer.
Tom Tromey's avatar
Tom Tromey committed
249
     The size of the buffer is always at least REMOTE_PACKET_SIZE;
250
251
     REMOTE_PACKET_SIZE should be used to limit the length of outgoing
     packets.  */
Tom Tromey's avatar
Tom Tromey committed
252
  gdb::char_vector buf;
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377

  /* True if we're going through initial connection setup (finding out
     about the remote side's threads, relocating symbols, etc.).  */
  bool starting_up = false;

  /* If we negotiated packet size explicitly (and thus can bypass
     heuristics for the largest packet size that will not overflow
     a buffer in the stub), this will be set to that packet size.
     Otherwise zero, meaning to use the guessed size.  */
  long explicit_packet_size = 0;

  /* remote_wait is normally called when the target is running and
     waits for a stop reply packet.  But sometimes we need to call it
     when the target is already stopped.  We can send a "?" packet
     and have remote_wait read the response.  Or, if we already have
     the response, we can stash it in BUF and tell remote_wait to
     skip calling getpkt.  This flag is set when BUF contains a
     stop reply packet and the target is not waiting.  */
  int cached_wait_status = 0;

  /* True, if in no ack mode.  That is, neither GDB nor the stub will
     expect acks from each other.  The connection is assumed to be
     reliable.  */
  bool noack_mode = false;

  /* True if we're connected in extended remote mode.  */
  bool extended = false;

  /* True if we resumed the target and we're waiting for the target to
     stop.  In the mean time, we can't start another command/query.
     The remote server wouldn't be ready to process it, so we'd
     timeout waiting for a reply that would never come and eventually
     we'd close the connection.  This can happen in asynchronous mode
     because we allow GDB commands while the target is running.  */
  bool waiting_for_stop_reply = false;

  /* The status of the stub support for the various vCont actions.  */
  vCont_action_support supports_vCont;

  /* True if the user has pressed Ctrl-C, but the target hasn't
     responded to that.  */
  bool ctrlc_pending_p = false;

  /* True if we saw a Ctrl-C while reading or writing from/to the
     remote descriptor.  At that point it is not safe to send a remote
     interrupt packet, so we instead remember we saw the Ctrl-C and
     process it once we're done with sending/receiving the current
     packet, which should be shortly.  If however that takes too long,
     and the user presses Ctrl-C again, we offer to disconnect.  */
  bool got_ctrlc_during_io = false;

  /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
     remote_open knows that we don't have a file open when the program
     starts.  */
  struct serial *remote_desc = nullptr;

  /* These are the threads which we last sent to the remote system.  The
     TID member will be -1 for all or -2 for not sent yet.  */
  ptid_t general_thread = null_ptid;
  ptid_t continue_thread = null_ptid;

  /* This is the traceframe which we last selected on the remote system.
     It will be -1 if no traceframe is selected.  */
  int remote_traceframe_number = -1;

  char *last_pass_packet = nullptr;

  /* The last QProgramSignals packet sent to the target.  We bypass
     sending a new program signals list down to the target if the new
     packet is exactly the same as the last we sent.  IOW, we only let
     the target know about program signals list changes.  */
  char *last_program_signals_packet = nullptr;

  gdb_signal last_sent_signal = GDB_SIGNAL_0;

  bool last_sent_step = false;

  /* The execution direction of the last resume we got.  */
  exec_direction_kind last_resume_exec_dir = EXEC_FORWARD;

  char *finished_object = nullptr;
  char *finished_annex = nullptr;
  ULONGEST finished_offset = 0;

  /* Should we try the 'ThreadInfo' query packet?

     This variable (NOT available to the user: auto-detect only!)
     determines whether GDB will use the new, simpler "ThreadInfo"
     query or the older, more complex syntax for thread queries.
     This is an auto-detect variable (set to true at each connect,
     and set to false when the target fails to recognize it).  */
  bool use_threadinfo_query = false;
  bool use_threadextra_query = false;

  threadref echo_nextthread {};
  threadref nextthread {};
  threadref resultthreadlist[MAXTHREADLISTRESULTS] {};

  /* The state of remote notification.  */
  struct remote_notif_state *notif_state = nullptr;

  /* The branch trace configuration.  */
  struct btrace_config btrace_config {};

  /* The argument to the last "vFile:setfs:" packet we sent, used
     to avoid sending repeated unnecessary "vFile:setfs:" packets.
     Initialized to -1 to indicate that no "vFile:setfs:" packet
     has yet been sent.  */
  int fs_pid = -1;

  /* A readahead cache for vFile:pread.  Often, reading a binary
     involves a sequence of small reads.  E.g., when parsing an ELF
     file.  A readahead cache helps mostly the case of remote
     debugging on a connection with higher latency, due to the
     request/reply nature of the RSP.  We only cache data for a single
     file descriptor at a time.  */
  struct readahead_cache readahead_cache;

  /* The list of already fetched and acknowledged stop events.  This
     queue is used for notification Stop, and other notifications
     don't need queue for their events, because the notification
     events of Stop can't be consumed immediately, so that events
     should be queued first, and be consumed by remote_wait_{ns,as}
     one per time.  Other notifications can consume their events
     immediately, so queue is not needed for them.  */
Tom Tromey's avatar
Tom Tromey committed
378
  std::vector<stop_reply_up> stop_reply_queue;
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399

  /* Asynchronous signal handle registered as event loop source for
     when we have pending events ready to be passed to the core.  */
  struct async_event_handler *remote_async_inferior_event_token = nullptr;

  /* FIXME: cagney/1999-09-23: Even though getpkt was called with
     ``forever'' still use the normal timeout mechanism.  This is
     currently used by the ASYNC code to guarentee that target reads
     during the initial connect always time-out.  Once getpkt has been
     modified to return a timeout indication and, in turn
     remote_wait()/wait_for_inferior() have gained a timeout parameter
     this can go away.  */
  int wait_forever_enabled_p = 1;

private:
  /* Mapping of remote protocol data for each gdbarch.  Usually there
     is only one entry here, though we may see more with stubs that
     support multi-process.  */
  std::unordered_map<struct gdbarch *, remote_arch_state>
    m_arch_states;
};
400

401
402
403
404
405
406
static const target_info remote_target_info = {
  "remote",
  N_("Remote serial target in gdb-specific protocol"),
  remote_doc
};

Pedro Alves's avatar
Pedro Alves committed
407
class remote_target : public process_stratum_target
Pedro Alves's avatar
Pedro Alves committed
408
409
{
public:
Pedro Alves's avatar
Pedro Alves committed
410
  remote_target () = default;
411
  ~remote_target () override;
Pedro Alves's avatar
Pedro Alves committed
412

413
414
  const target_info &info () const override
  { return remote_target_info; }
Pedro Alves's avatar
Pedro Alves committed
415
416
417
418

  thread_control_capabilities get_thread_control_capabilities () override
  { return tc_schedlock; }

419
420
421
  /* Open a remote connection.  */
  static void open (const char *, int);

Pedro Alves's avatar
Pedro Alves committed
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
  void close () override;

  void detach (inferior *, int) override;
  void disconnect (const char *, int) override;

  void commit_resume () override;
  void resume (ptid_t, int, enum gdb_signal) override;
  ptid_t wait (ptid_t, struct target_waitstatus *, int) override;

  void fetch_registers (struct regcache *, int) override;
  void store_registers (struct regcache *, int) override;
  void prepare_to_store (struct regcache *) override;

  void files_info () override;

  int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;

  int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
			 enum remove_bp_reason) override;


Pedro Alves's avatar
Pedro Alves committed
443
444
  bool stopped_by_sw_breakpoint () override;
  bool supports_stopped_by_sw_breakpoint () override;
Pedro Alves's avatar
Pedro Alves committed
445

Pedro Alves's avatar
Pedro Alves committed
446
  bool stopped_by_hw_breakpoint () override;
Pedro Alves's avatar
Pedro Alves committed
447

Pedro Alves's avatar
Pedro Alves committed
448
  bool supports_stopped_by_hw_breakpoint () override;
Pedro Alves's avatar
Pedro Alves committed
449

Pedro Alves's avatar
Pedro Alves committed
450
  bool stopped_by_watchpoint () override;
Pedro Alves's avatar
Pedro Alves committed
451

Pedro Alves's avatar
Pedro Alves committed
452
  bool stopped_data_address (CORE_ADDR *) override;
Pedro Alves's avatar
Pedro Alves committed
453

Pedro Alves's avatar
Pedro Alves committed
454
  bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
Pedro Alves's avatar
Pedro Alves committed
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475

  int can_use_hw_breakpoint (enum bptype, int, int) override;

  int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;

  int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;

  int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;

  int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
			 struct expression *) override;

  int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
			 struct expression *) override;

  void kill () override;

  void load (const char *, int) override;

  void mourn_inferior () override;

476
  void pass_signals (int, const unsigned char *) override;
Pedro Alves's avatar
Pedro Alves committed
477
478
479
480

  int set_syscall_catchpoint (int, bool, int,
			      gdb::array_view<const int>) override;

481
  void program_signals (int, const unsigned char *) override;
Pedro Alves's avatar
Pedro Alves committed
482

Pedro Alves's avatar
Pedro Alves committed
483
  bool thread_alive (ptid_t ptid) override;
Pedro Alves's avatar
Pedro Alves committed
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526

  const char *thread_name (struct thread_info *) override;

  void update_thread_list () override;

  const char *pid_to_str (ptid_t) override;

  const char *extra_thread_info (struct thread_info *) override;

  ptid_t get_ada_task_ptid (long lwp, long thread) override;

  thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle,
					     int handle_len,
					     inferior *inf) override;

  void stop (ptid_t) override;

  void interrupt () override;

  void pass_ctrlc () override;

  enum target_xfer_status xfer_partial (enum target_object object,
					const char *annex,
					gdb_byte *readbuf,
					const gdb_byte *writebuf,
					ULONGEST offset, ULONGEST len,
					ULONGEST *xfered_len) override;

  ULONGEST get_memory_xfer_limit () override;

  void rcmd (const char *command, struct ui_file *output) override;

  char *pid_to_exec_file (int pid) override;

  void log_command (const char *cmd) override
  {
    serial_log_command (this, cmd);
  }

  CORE_ADDR get_thread_local_address (ptid_t ptid,
				      CORE_ADDR load_module_addr,
				      CORE_ADDR offset) override;

Pedro Alves's avatar
Pedro Alves committed
527
  bool can_execute_reverse () override;
Pedro Alves's avatar
Pedro Alves committed
528
529
530
531
532
533
534
535
536
537
538
539
540

  std::vector<mem_region> memory_map () override;

  void flash_erase (ULONGEST address, LONGEST length) override;

  void flash_done () override;

  const struct target_desc *read_description () override;

  int search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
		     const gdb_byte *pattern, ULONGEST pattern_len,
		     CORE_ADDR *found_addrp) override;

Pedro Alves's avatar
Pedro Alves committed
541
  bool can_async_p () override;
Pedro Alves's avatar
Pedro Alves committed
542

Pedro Alves's avatar
Pedro Alves committed
543
  bool is_async_p () override;
Pedro Alves's avatar
Pedro Alves committed
544
545
546
547
548
549
550
551
552
553
554

  void async (int) override;

  void thread_events (int) override;

  int can_do_single_step () override;

  void terminal_inferior () override;

  void terminal_ours () override;

Pedro Alves's avatar
Pedro Alves committed
555
  bool supports_non_stop () override;
Pedro Alves's avatar
Pedro Alves committed
556

Pedro Alves's avatar
Pedro Alves committed
557
  bool supports_multi_process () override;
Pedro Alves's avatar
Pedro Alves committed
558

Pedro Alves's avatar
Pedro Alves committed
559
  bool supports_disable_randomization () override;
Pedro Alves's avatar
Pedro Alves committed
560

Pedro Alves's avatar
Pedro Alves committed
561
  bool filesystem_is_local () override;
Pedro Alves's avatar
Pedro Alves committed
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586


  int fileio_open (struct inferior *inf, const char *filename,
		   int flags, int mode, int warn_if_slow,
		   int *target_errno) override;

  int fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
		     ULONGEST offset, int *target_errno) override;

  int fileio_pread (int fd, gdb_byte *read_buf, int len,
		    ULONGEST offset, int *target_errno) override;

  int fileio_fstat (int fd, struct stat *sb, int *target_errno) override;

  int fileio_close (int fd, int *target_errno) override;

  int fileio_unlink (struct inferior *inf,
		     const char *filename,
		     int *target_errno) override;

  gdb::optional<std::string>
    fileio_readlink (struct inferior *inf,
		     const char *filename,
		     int *target_errno) override;

Pedro Alves's avatar
Pedro Alves committed
587
  bool supports_enable_disable_tracepoint () override;
Pedro Alves's avatar
Pedro Alves committed
588

Pedro Alves's avatar
Pedro Alves committed
589
  bool supports_string_tracing () override;
Pedro Alves's avatar
Pedro Alves committed
590

Pedro Alves's avatar
Pedro Alves committed
591
  bool supports_evaluation_of_breakpoint_conditions () override;
Pedro Alves's avatar
Pedro Alves committed
592

Pedro Alves's avatar
Pedro Alves committed
593
  bool can_run_breakpoint_commands () override;
Pedro Alves's avatar
Pedro Alves committed
594
595
596
597
598

  void trace_init () override;

  void download_tracepoint (struct bp_location *location) override;

Pedro Alves's avatar
Pedro Alves committed
599
  bool can_download_tracepoint () override;
Pedro Alves's avatar
Pedro Alves committed
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620

  void download_trace_state_variable (const trace_state_variable &tsv) override;

  void enable_tracepoint (struct bp_location *location) override;

  void disable_tracepoint (struct bp_location *location) override;

  void trace_set_readonly_regions () override;

  void trace_start () override;

  int get_trace_status (struct trace_status *ts) override;

  void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
    override;

  void trace_stop () override;

  int trace_find (enum trace_find_type type, int num,
		  CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override;

Pedro Alves's avatar
Pedro Alves committed
621
  bool get_trace_state_variable_value (int tsv, LONGEST *val) override;
Pedro Alves's avatar
Pedro Alves committed
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638

  int save_trace_data (const char *filename) override;

  int upload_tracepoints (struct uploaded_tp **utpp) override;

  int upload_trace_state_variables (struct uploaded_tsv **utsvp) override;

  LONGEST get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) override;

  int get_min_fast_tracepoint_insn_len () override;

  void set_disconnected_tracing (int val) override;

  void set_circular_trace_buffer (int val) override;

  void set_trace_buffer_size (LONGEST val) override;

Pedro Alves's avatar
Pedro Alves committed
639
640
  bool set_trace_notes (const char *user, const char *notes,
			const char *stopnotes) override;
Pedro Alves's avatar
Pedro Alves committed
641
642
643
644
645
646
647

  int core_of_thread (ptid_t ptid) override;

  int verify_memory (const gdb_byte *data,
		     CORE_ADDR memaddr, ULONGEST size) override;


Pedro Alves's avatar
Pedro Alves committed
648
  bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
Pedro Alves's avatar
Pedro Alves committed
649
650
651
652
653
654
655
656
657
658
659
660

  void set_permissions () override;

  bool static_tracepoint_marker_at (CORE_ADDR,
				    struct static_tracepoint_marker *marker)
    override;

  std::vector<static_tracepoint_marker>
    static_tracepoint_markers_by_strid (const char *id) override;

  traceframe_info_up traceframe_info () override;

Pedro Alves's avatar
Pedro Alves committed
661
662
  bool use_agent (bool use) override;
  bool can_use_agent () override;
Pedro Alves's avatar
Pedro Alves committed
663
664
665
666
667
668
669
670
671
672
673
674
675

  struct btrace_target_info *enable_btrace (ptid_t ptid,
					    const struct btrace_config *conf) override;

  void disable_btrace (struct btrace_target_info *tinfo) override;

  void teardown_btrace (struct btrace_target_info *tinfo) override;

  enum btrace_error read_btrace (struct btrace_data *data,
				 struct btrace_target_info *btinfo,
				 enum btrace_read_type type) override;

  const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
Pedro Alves's avatar
Pedro Alves committed
676
  bool augmented_libraries_svr4_read () override;
Pedro Alves's avatar
Pedro Alves committed
677
678
679
680
681
682
683
684
685
686
  int follow_fork (int, int) override;
  void follow_exec (struct inferior *, char *) override;
  int insert_fork_catchpoint (int) override;
  int remove_fork_catchpoint (int) override;
  int insert_vfork_catchpoint (int) override;
  int remove_vfork_catchpoint (int) override;
  int insert_exec_catchpoint (int) override;
  int remove_exec_catchpoint (int) override;
  enum exec_direction_kind execution_direction () override;

687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
public: /* Remote specific methods.  */

  void remote_download_command_source (int num, ULONGEST addr,
				       struct command_line *cmds);

  void remote_file_put (const char *local_file, const char *remote_file,
			int from_tty);
  void remote_file_get (const char *remote_file, const char *local_file,
			int from_tty);
  void remote_file_delete (const char *remote_file, int from_tty);

  int remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
			   ULONGEST offset, int *remote_errno);
  int remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
			    ULONGEST offset, int *remote_errno);
  int remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
				 ULONGEST offset, int *remote_errno);

  int remote_hostio_send_command (int command_bytes, int which_packet,
				  int *remote_errno, char **attachment,
				  int *attachment_len);
  int remote_hostio_set_filesystem (struct inferior *inf,
				    int *remote_errno);
  /* We should get rid of this and use fileio_open directly.  */
  int remote_hostio_open (struct inferior *inf, const char *filename,
			  int flags, int mode, int warn_if_slow,
			  int *remote_errno);
  int remote_hostio_close (int fd, int *remote_errno);

  int remote_hostio_unlink (inferior *inf, const char *filename,
			    int *remote_errno);

  struct remote_state *get_remote_state ();

  long get_remote_packet_size (void);
  long get_memory_packet_size (struct memory_packet_config *config);

  long get_memory_write_packet_size ();
  long get_memory_read_packet_size ();

  char *append_pending_thread_resumptions (char *p, char *endp,
					   ptid_t ptid);
729
  static void open_1 (const char *name, int from_tty, int extended_p);
Pedro Alves's avatar
Pedro Alves committed
730
  void start_remote (int from_tty, int extended_p);
731
  void remote_detach_1 (struct inferior *inf, int from_tty);
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751

  char *append_resumption (char *p, char *endp,
			   ptid_t ptid, int step, gdb_signal siggnal);
  int remote_resume_with_vcont (ptid_t ptid, int step,
				gdb_signal siggnal);

  void add_current_inferior_and_thread (char *wait_status);

  ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status,
		  int options);
  ptid_t wait_as (ptid_t ptid, target_waitstatus *status,
		  int options);

  ptid_t process_stop_reply (struct stop_reply *stop_reply,
			     target_waitstatus *status);

  void remote_notice_new_inferior (ptid_t currthread, int executing);

  void process_initial_stop_replies (int from_tty);

752
  thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing);
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769

  void btrace_sync_conf (const btrace_config *conf);

  void remote_btrace_maybe_reopen ();

  void remove_new_fork_children (threads_listing_context *context);
  void kill_new_fork_children (int pid);
  void discard_pending_stop_replies (struct inferior *inf);
  int stop_reply_queue_length ();

  void check_pending_events_prevent_wildcard_vcont
    (int *may_global_wildcard_vcont);

  void discard_pending_stop_replies_in_queue ();
  struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
  struct stop_reply *queued_stop_reply (ptid_t ptid);
  int peek_stop_reply (ptid_t ptid);
770
  void remote_parse_stop_reply (const char *buf, stop_reply *event);
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894

  void remote_stop_ns (ptid_t ptid);
  void remote_interrupt_as ();
  void remote_interrupt_ns ();

  char *remote_get_noisy_reply ();
  int remote_query_attached (int pid);
  inferior *remote_add_inferior (int fake_pid_p, int pid, int attached,
				 int try_open_exec);

  ptid_t remote_current_thread (ptid_t oldpid);
  ptid_t get_current_thread (char *wait_status);

  void set_thread (ptid_t ptid, int gen);
  void set_general_thread (ptid_t ptid);
  void set_continue_thread (ptid_t ptid);
  void set_general_process ();

  char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);

  int remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
					  gdb_ext_thread_info *info);
  int remote_get_threadinfo (threadref *threadid, int fieldset,
			     gdb_ext_thread_info *info);

  int parse_threadlist_response (char *pkt, int result_limit,
				 threadref *original_echo,
				 threadref *resultlist,
				 int *doneflag);
  int remote_get_threadlist (int startflag, threadref *nextthread,
			     int result_limit, int *done, int *result_count,
			     threadref *threadlist);

  int remote_threadlist_iterator (rmt_thread_action stepfunction,
				  void *context, int looplimit);

  int remote_get_threads_with_ql (threads_listing_context *context);
  int remote_get_threads_with_qxfer (threads_listing_context *context);
  int remote_get_threads_with_qthreadinfo (threads_listing_context *context);

  void extended_remote_restart ();

  void get_offsets ();

  void remote_check_symbols ();

  void remote_supported_packet (const struct protocol_feature *feature,
				enum packet_support support,
				const char *argument);

  void remote_query_supported ();

  void remote_packet_size (const protocol_feature *feature,
			   packet_support support, const char *value);

  void remote_serial_quit_handler ();

  void remote_detach_pid (int pid);

  void remote_vcont_probe ();

  void remote_resume_with_hc (ptid_t ptid, int step,
			      gdb_signal siggnal);

  void send_interrupt_sequence ();
  void interrupt_query ();

  void remote_notif_get_pending_events (notif_client *nc);

  int fetch_register_using_p (struct regcache *regcache,
			      packet_reg *reg);
  int send_g_packet ();
  void process_g_packet (struct regcache *regcache);
  void fetch_registers_using_g (struct regcache *regcache);
  int store_register_using_P (const struct regcache *regcache,
			      packet_reg *reg);
  void store_registers_using_G (const struct regcache *regcache);

  void set_remote_traceframe ();

  void check_binary_download (CORE_ADDR addr);

  target_xfer_status remote_write_bytes_aux (const char *header,
					     CORE_ADDR memaddr,
					     const gdb_byte *myaddr,
					     ULONGEST len_units,
					     int unit_size,
					     ULONGEST *xfered_len_units,
					     char packet_format,
					     int use_length);

  target_xfer_status remote_write_bytes (CORE_ADDR memaddr,
					 const gdb_byte *myaddr, ULONGEST len,
					 int unit_size, ULONGEST *xfered_len);

  target_xfer_status remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
					  ULONGEST len_units,
					  int unit_size, ULONGEST *xfered_len_units);

  target_xfer_status remote_xfer_live_readonly_partial (gdb_byte *readbuf,
							ULONGEST memaddr,
							ULONGEST len,
							int unit_size,
							ULONGEST *xfered_len);

  target_xfer_status remote_read_bytes (CORE_ADDR memaddr,
					gdb_byte *myaddr, ULONGEST len,
					int unit_size,
					ULONGEST *xfered_len);

  packet_result remote_send_printf (const char *format, ...)
    ATTRIBUTE_PRINTF (2, 3);

  target_xfer_status remote_flash_write (ULONGEST address,
					 ULONGEST length, ULONGEST *xfered_len,
					 const gdb_byte *data);

  int readchar (int timeout);

  void remote_serial_write (const char *str, int len);

  int putpkt (const char *buf);
  int putpkt_binary (const char *buf, int cnt);

Tom Tromey's avatar
Tom Tromey committed
895
896
897
898
899
  int putpkt (const gdb::char_vector &buf)
  {
    return putpkt (buf.data ());
  }

900
  void skip_frame ();
Tom Tromey's avatar
Tom Tromey committed
901
902
903
  long read_frame (gdb::char_vector *buf_p);
  void getpkt (gdb::char_vector *buf, int forever);
  int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever,
904
			      int expecting_notif, int *is_notif);
Tom Tromey's avatar
Tom Tromey committed
905
906
  int getpkt_sane (gdb::char_vector *buf, int forever);
  int getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
907
908
909
910
911
912
913
914
915
916
917
918
			    int *is_notif);
  int remote_vkill (int pid);
  void remote_kill_k ();

  void extended_remote_disable_randomization (int val);
  int extended_remote_run (const std::string &args);

  void send_environment_packet (const char *action,
				const char *packet,
				const char *value);

  void extended_remote_environment_support ();
919
  void extended_remote_set_inferior_cwd ();
920

921
922
923
924
925
926
  target_xfer_status remote_write_qxfer (const char *object_name,
					 const char *annex,
					 const gdb_byte *writebuf,
					 ULONGEST offset, LONGEST len,
					 ULONGEST *xfered_len,
					 struct packet_config *packet);
927

928
929
930
931
932
933
  target_xfer_status remote_read_qxfer (const char *object_name,
					const char *annex,
					gdb_byte *readbuf, ULONGEST offset,
					LONGEST len,
					ULONGEST *xfered_len,
					struct packet_config *packet);
934

935
  void push_stop_reply (struct stop_reply *new_event);
936

937
  bool vcont_r_supported ();
938

939
  void packet_command (const char *args, int from_tty);
940

941
private: /* data fields */
942

943
944
945
  /* The remote state.  Don't reference this directly.  Use the
     get_remote_state method instead.  */
  remote_state m_remote_state;
946
947
};

948
949
950
951
952
static const target_info extended_remote_target_info = {
  "extended-remote",
  N_("Extended remote serial target in gdb-specific protocol"),
  remote_doc
};
953

954
955
956
957
/* Set up the extended remote target by extending the standard remote
   target and adding to it.  */

class extended_remote_target final : public remote_target
958
{
959
public:
960
961
  const target_info &info () const override
  { return extended_remote_target_info; }
962

963
964
  /* Open an extended-remote connection.  */
  static void open (const char *, int);
965

966
967
968
  bool can_create_inferior () override { return true; }
  void create_inferior (const char *, const std::string &,
			char **, int) override;
969

970
  void detach (inferior *, int) override;
971

972
973
  bool can_attach () override { return true; }
  void attach (const char *, int) override;
Daniel Jacobowitz's avatar
gdb/    
Daniel Jacobowitz committed
974

975
976
977
  void post_attach (int) override;
  bool supports_disable_randomization () override;
};
978

979
980
/* Per-program-space data key.  */
static const struct program_space_data *remote_pspace_data;
981

982
983
984
985
986
/* The variable registered as the control variable used by the
   remote exec-file commands.  While the remote exec-file setting is
   per-program-space, the set/show machinery uses this as the 
   location of the remote exec-file value.  */
static char *remote_exec_file_var;
Sandra Loosemore's avatar
Sandra Loosemore committed
987

988
989
990
991
992
993
994
/* The size to align memory write packets, when practical.  The protocol
   does not guarantee any alignment, and gdb will generate short
   writes and unaligned writes, but even as a best-effort attempt this
   can improve bulk transfers.  For instance, if a write is misaligned
   relative to the target's data bus, the stub may need to make an extra
   round trip fetching data from the target.  This doesn't make a
   huge difference, but it's easy to do, so we try to be helpful.
995

996
997
998
   The alignment chosen is arbitrary; usually data bus width is
   important here, not the possibly larger cache line size.  */
enum { REMOTE_ALIGN_WRITES = 16 };
999

1000
/* Prototypes for local functions.  */
For faster browsing, not all history is shown. View entire blame